[deliverable/binutils-gdb.git] / gdb / sun386-xdep.c

/* Machine-dependent code for host Sun 386i's for GDB, the GNU debugger.
   Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
   Changes for sun386i by Jean Daniel Fekete (jdf@litp.univ-p6-7.fr),
   C2V Paris, April 89.

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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#if defined (GDB_TARGET_IS_SUN386)

#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "gdbcore.h"

#include <sys/param.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <fcntl.h>

#include <sys/ptrace.h>
#include <machine/reg.h>

#include <sys/file.h>
#include <sys/stat.h>
#include <sys/core.h>

\f
void
fetch_inferior_registers (regno)
     int regno;
{
  struct regs inferior_registers;
  struct fp_state inferior_fp_registers;
  extern char registers[];

  registers_fetched ();

  ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers);
  ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers);

  bcopy (&inferior_registers, registers, sizeof inferior_registers);

  bcopy (inferior_fp_registers.f_st,&registers[REGISTER_BYTE (FP0_REGNUM)],
	 sizeof inferior_fp_registers.f_st);
  bcopy (&inferior_fp_registers.f_ctrl,
	 &registers[REGISTER_BYTE (FPC_REGNUM)],
	 sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
}

/* 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;
{
  struct regs inferior_registers;
  struct fp_state inferior_fp_registers;
  extern char registers[];

  bcopy (registers, &inferior_registers, 20 * 4);

  bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)],inferior_fp_registers.f_st,
	 sizeof inferior_fp_registers.f_st);
  bcopy (&registers[REGISTER_BYTE (FPC_REGNUM)],
	 &inferior_fp_registers.f_ctrl,
	 sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
  
#ifdef PTRACE_FP_BUG
  if (regno == FP_REGNUM || regno == -1)
    /* Storing the frame pointer requires a gross hack, in which an
       instruction that moves eax into ebp gets single-stepped.  */
    {
      int stack = inferior_registers.r_reg[SP_REGNUM];
      int stuff = ptrace (PTRACE_PEEKDATA, inferior_pid, stack);
      int reg = inferior_registers.r_reg[EAX];
      inferior_registers.r_reg[EAX] =
	inferior_registers.r_reg[FP_REGNUM];
      ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
      ptrace (PTRACE_POKEDATA, inferior_pid, stack, 0xc589);
      ptrace (PTRACE_SINGLESTEP, inferior_pid, stack, 0);
      wait (0);
      ptrace (PTRACE_POKEDATA, inferior_pid, stack, stuff);
      inferior_registers.r_reg[EAX] = reg;
    }
#endif
  ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
  ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers);
}

/* Machine-dependent code which would otherwise be in core.c */
/* Work with core files, for GDB. */

\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 inferior with \"kill\".");
      corechan = open (filename, O_RDONLY, 0);
      if (corechan < 0)
	perror_with_name (filename);

      {
	struct core corestr;

	val = myread (corechan, &corestr, sizeof corestr);
	if (val < 0)
	  perror_with_name (filename);
	if (corestr.c_magic != CORE_MAGIC)
	  error ("\"%s\" does not appear to be a core dump file (magic 0x%x, expected 0x%x)",
		 filename, corestr.c_magic, (int) CORE_MAGIC);
	else if (sizeof (struct core) != corestr.c_len)
	  error ("\"%s\" has an invalid struct core length (%d, expected %d)",
		 filename, corestr.c_len, (int) sizeof (struct core));

	data_start = exec_data_start;
	data_end = data_start + corestr.c_dsize;
	stack_start = stack_end - corestr.c_ssize;
	data_offset = sizeof corestr;
	stack_offset = sizeof corestr + corestr.c_dsize;

	bcopy (&corestr.c_regs, registers, sizeof corestr.c_regs);

	bcopy (corestr.c_fpu.f_fpstatus.f_st,
	       &registers[REGISTER_BYTE (FP0_REGNUM)],
	       sizeof corestr.c_fpu.f_fpstatus.f_st);
	bcopy (&corestr.c_fpu.f_fpstatus.f_ctrl,
	       &registers[REGISTER_BYTE (FPC_REGNUM)],
	       sizeof corestr.c_fpu.f_fpstatus -
	       sizeof corestr.c_fpu.f_fpstatus.f_st);

	/* the struct aouthdr of sun coff is not the struct exec stored
	   in the core file. */
	bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec));
#ifndef COFF_ENCAPSULATE
	core_aouthdr.magic = corestr.c_aouthdr.a_info;
	core_aouthdr.vstamp = /*SUNVERSION*/ 31252;
#endif
	printf ("Core file is from \"%s\".\n", corestr.c_cmdname);
	if (corestr.c_signo > 0)
	  printf ("Program terminated with signal %d, %s.\n",
		  corestr.c_signo, safe_strsignal (corestr.c_signo));
      }
      if (filename[0] == '/')
	corefile = savestring (filename, strlen (filename));
      else
	{
	  corefile = concat (current_directory, "/", filename, NULL);
	}

      set_current_frame ( create_new_frame (read_register (FP_REGNUM),
					    read_pc ()));
      select_frame (get_current_frame (), 0);

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

i387_to_double (from, to)
     char *from;
     char *to;
{
  long *lp;
  /* push extended mode on 387 stack, then pop in double mode
   *
   * first, set exception masks so no error is generated -
   * number will be rounded to inf or 0, if necessary 
   */
  asm ("pushl %eax"); 		/* grab a stack slot */
  asm ("fstcw (%esp)");		/* get 387 control word */
  asm ("movl (%esp),%eax");	/* save old value */
  asm ("orl $0x3f,%eax");		/* mask all exceptions */
  asm ("pushl %eax");
  asm ("fldcw (%esp)");		/* load new value into 387 */
  
  asm ("movl 8(%ebp),%eax");
  asm ("fldt (%eax)");		/* push extended number on 387 stack */
  asm ("fwait");
  asm ("movl 12(%ebp),%eax");
  asm ("fstpl (%eax)");		/* pop double */
  asm ("fwait");
  
  asm ("popl %eax");		/* flush modified control word */
  asm ("fnclex");			/* clear exceptions */
  asm ("fldcw (%esp)");		/* restore original control word */
  asm ("popl %eax");		/* flush saved copy */
}

double_to_i387 (from, to)
     char *from;
     char *to;
{
  /* push double mode on 387 stack, then pop in extended mode
   * no errors are possible because every 64-bit pattern
   * can be converted to an extended
   */
  asm ("movl 8(%ebp),%eax");
  asm ("fldl (%eax)");
  asm ("fwait");
  asm ("movl 12(%ebp),%eax");
  asm ("fstpt (%eax)");
  asm ("fwait");
}
#else /* Not sun386 target.  */

/* These functions shouldn't be called when we're cross-debugging.  */

/* ARGSUSED */
void
fetch_inferior_registers (regno)
     int regno;
{
}

/* ARGSUSED */
void
store_inferior_registers (regno)
     int regno;
{
}

/* ARGSUSED */
void
fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
     char *core_reg_sect;
     unsigned core_reg_size;
     int which;
     unsigned int reg_addr;	/* Unused in this version */
{
}

#endif /* Not sun386 target.  */
Commit	Line	Data
dd3b648e RP	1	/* Machine-dependent code for host Sun 386i's for GDB, the GNU debugger.
	2	Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
	3	Changes for sun386i by Jean Daniel Fekete (jdf@litp.univ-p6-7.fr),
	4	C2V Paris, April 89.
	5
	6	This file is part of GDB.
	7
99a7de40	8	This program is free software; you can redistribute it and/or modify
dd3b648e	9	it under the terms of the GNU General Public License as published by
99a7de40 JG	10	the Free Software Foundation; either version 2 of the License, or
99a7de40 JG	11	(at your option) any later version.
dd3b648e	12
99a7de40	13	This program is distributed in the hope that it will be useful,
dd3b648e RP	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
99a7de40 JG	19	along with this program; if not, write to the Free Software
99a7de40 JG	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
dd3b648e	21
f0ca24b9 JK	22	#if defined (GDB_TARGET_IS_SUN386)
f0ca24b9 JK	23
dd3b648e	24	#include "defs.h"
dd3b648e RP	25	#include "frame.h"
dd3b648e RP	26	#include "inferior.h"
dd3b648e RP	27	#include "gdbcore.h"
	28
	29	#include <sys/param.h>
	30	#include <sys/dir.h>
	31	#include <sys/user.h>
	32	#include <signal.h>
	33	#include <sys/ioctl.h>
	34	#include <fcntl.h>
	35
	36	#include <sys/ptrace.h>
	37	#include <machine/reg.h>
	38
	39	#include <sys/file.h>
	40	#include <sys/stat.h>
	41	#include <sys/core.h>
7919c3ed	42
dd3b648e RP	43	\f
dd3b648e RP	44	void
7919c3ed JG	45	fetch_inferior_registers (regno)
7919c3ed JG	46	int regno;
dd3b648e RP	47	{
	48	struct regs inferior_registers;
	49	struct fp_state inferior_fp_registers;
	50	extern char registers[];
	51
	52	registers_fetched ();
	53
	54	ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers);
	55	ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers);
	56
	57	bcopy (&inferior_registers, registers, sizeof inferior_registers);
	58
	59	bcopy (inferior_fp_registers.f_st,&registers[REGISTER_BYTE (FP0_REGNUM)],
	60	sizeof inferior_fp_registers.f_st);
	61	bcopy (&inferior_fp_registers.f_ctrl,
	62	&registers[REGISTER_BYTE (FPC_REGNUM)],
	63	sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
	64	}
	65
	66	/* Store our register values back into the inferior.
	67	If REGNO is -1, do this for all registers.
	68	Otherwise, REGNO specifies which register (so we can save time). */
	69
7919c3ed	70	void
dd3b648e RP	71	store_inferior_registers (regno)
	72	int regno;
	73	{
	74	struct regs inferior_registers;
	75	struct fp_state inferior_fp_registers;
	76	extern char registers[];
	77
	78	bcopy (registers, &inferior_registers, 20 * 4);
	79
	80	bcopy (&registers[REGISTER_BYTE (FP0_REGNUM)],inferior_fp_registers.f_st,
	81	sizeof inferior_fp_registers.f_st);
	82	bcopy (&registers[REGISTER_BYTE (FPC_REGNUM)],
	83	&inferior_fp_registers.f_ctrl,
	84	sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st);
	85
	86	#ifdef PTRACE_FP_BUG
	87	if (regno == FP_REGNUM \|\| regno == -1)
	88	/* Storing the frame pointer requires a gross hack, in which an
	89	instruction that moves eax into ebp gets single-stepped. */
	90	{
	91	int stack = inferior_registers.r_reg[SP_REGNUM];
	92	int stuff = ptrace (PTRACE_PEEKDATA, inferior_pid, stack);
	93	int reg = inferior_registers.r_reg[EAX];
	94	inferior_registers.r_reg[EAX] =
	95	inferior_registers.r_reg[FP_REGNUM];
	96	ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
	97	ptrace (PTRACE_POKEDATA, inferior_pid, stack, 0xc589);
	98	ptrace (PTRACE_SINGLESTEP, inferior_pid, stack, 0);
	99	wait (0);
	100	ptrace (PTRACE_POKEDATA, inferior_pid, stack, stuff);
	101	inferior_registers.r_reg[EAX] = reg;
	102	}
	103	#endif
	104	ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers);
	105	ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers);
	106	}
	107
	108	/* Machine-dependent code which would otherwise be in core.c */
	109	/* Work with core files, for GDB. */
	110
	111	\f
	112	void
	113	core_file_command (filename, from_tty)
	114	char *filename;
	115	int from_tty;
	116	{
	117	int val;
	118	extern char registers[];
	119
	120	/* Discard all vestiges of any previous core file
	121	and mark data and stack spaces as empty. */
	122
	123	if (corefile)
	124	free (corefile);
	125	corefile = 0;
	126
	127	if (corechan >= 0)
	128	close (corechan);
	129	corechan = -1;
	130
	131	data_start = 0;
	132	data_end = 0;
	133	stack_start = STACK_END_ADDR;
	134	stack_end = STACK_END_ADDR;
135
136	/* Now, if a new core file was specified, open it and digest it. */
137
138	if (filename)
139	{
140	filename = tilde_expand (filename);
141	make_cleanup (free, filename);
142
143	if (have_inferior_p ())
144	error ("To look at a core file, you must kill the inferior with \"kill\".");
145	corechan = open (filename, O_RDONLY, 0);
146	if (corechan < 0)
147	perror_with_name (filename);
148
149	{
150	struct core corestr;
151
152	val = myread (corechan, &corestr, sizeof corestr);
153	if (val < 0)
154	perror_with_name (filename);
155	if (corestr.c_magic != CORE_MAGIC)
156	error ("\"%s\" does not appear to be a core dump file (magic 0x%x, expected 0x%x)",
157	filename, corestr.c_magic, (int) CORE_MAGIC);
158	else if (sizeof (struct core) != corestr.c_len)
159	error ("\"%s\" has an invalid struct core length (%d, expected %d)",
160	filename, corestr.c_len, (int) sizeof (struct core));
161
162	data_start = exec_data_start;
163	data_end = data_start + corestr.c_dsize;
164	stack_start = stack_end - corestr.c_ssize;
165	data_offset = sizeof corestr;
166	stack_offset = sizeof corestr + corestr.c_dsize;
167
168	bcopy (&corestr.c_regs, registers, sizeof corestr.c_regs);
169
170	bcopy (corestr.c_fpu.f_fpstatus.f_st,
171	&registers[REGISTER_BYTE (FP0_REGNUM)],
172	sizeof corestr.c_fpu.f_fpstatus.f_st);
173	bcopy (&corestr.c_fpu.f_fpstatus.f_ctrl,
174	&registers[REGISTER_BYTE (FPC_REGNUM)],
175	sizeof corestr.c_fpu.f_fpstatus -
176	sizeof corestr.c_fpu.f_fpstatus.f_st);
177
178	/* the struct aouthdr of sun coff is not the struct exec stored
179	in the core file. */
180	bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec));
181	#ifndef COFF_ENCAPSULATE
182	core_aouthdr.magic = corestr.c_aouthdr.a_info;
183	core_aouthdr.vstamp = /SUNVERSION/ 31252;
184	#endif
185	printf ("Core file is from \"%s\".\n", corestr.c_cmdname);
186	if (corestr.c_signo > 0)
187	printf ("Program terminated with signal %d, %s.\n",
4ace50a5	188	corestr.c_signo, safe_strsignal (corestr.c_signo));
dd3b648e RP	189	}
	190	if (filename[0] == '/')
	191	corefile = savestring (filename, strlen (filename));
	192	else
	193	{
58ae87f6	194	corefile = concat (current_directory, "/", filename, NULL);
dd3b648e RP	195	}
	196
	197	set_current_frame ( create_new_frame (read_register (FP_REGNUM),
	198	read_pc ()));
	199	select_frame (get_current_frame (), 0);
	200
	201	validate_files ();
	202	}
	203	else if (from_tty)
	204	printf ("No core file now.\n");
	205	}
	206
	207	i387_to_double (from, to)
	208	char *from;
	209	char *to;
	210	{
	211	long *lp;
	212	/* push extended mode on 387 stack, then pop in double mode
	213	*
	214	* first, set exception masks so no error is generated -
	215	* number will be rounded to inf or 0, if necessary
	216	*/
	217	asm ("pushl %eax"); /* grab a stack slot */
	218	asm ("fstcw (%esp)"); /* get 387 control word */
	219	asm ("movl (%esp),%eax"); /* save old value */
	220	asm ("orl $0x3f,%eax"); /* mask all exceptions */
	221	asm ("pushl %eax");
	222	asm ("fldcw (%esp)"); /* load new value into 387 */
	223
	224	asm ("movl 8(%ebp),%eax");
	225	asm ("fldt (%eax)"); /* push extended number on 387 stack */
	226	asm ("fwait");
	227	asm ("movl 12(%ebp),%eax");
	228	asm ("fstpl (%eax)"); /* pop double */
	229	asm ("fwait");
	230
	231	asm ("popl %eax"); /* flush modified control word */
	232	asm ("fnclex"); /* clear exceptions */
	233	asm ("fldcw (%esp)"); /* restore original control word */
	234	asm ("popl %eax"); /* flush saved copy */
	235	}
	236
	237	double_to_i387 (from, to)
	238	char *from;
	239	char *to;
	240	{
	241	/* push double mode on 387 stack, then pop in extended mode
	242	* no errors are possible because every 64-bit pattern
	243	* can be converted to an extended
	244	*/
	245	asm ("movl 8(%ebp),%eax");
	246	asm ("fldl (%eax)");
	247	asm ("fwait");
	248	asm ("movl 12(%ebp),%eax");
	249	asm ("fstpt (%eax)");
	250	asm ("fwait");
	251	}
f0ca24b9 JK	252	#else /* Not sun386 target. */
	253
	254	/* These functions shouldn't be called when we're cross-debugging. */
	255
7919c3ed	256	/* ARGSUSED */
f0ca24b9	257	void
7919c3ed JG	258	fetch_inferior_registers (regno)
7919c3ed JG	259	int regno;
f0ca24b9 JK	260	{
	261	}
	262
	263	/* ARGSUSED */
7919c3ed	264	void
f0ca24b9 JK	265	store_inferior_registers (regno)
	266	int regno;
	267	{
	268	}
	269
	270	/* ARGSUSED */
	271	void
7919c3ed	272	fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
f0ca24b9 JK	273	char *core_reg_sect;
	274	unsigned core_reg_size;
	275	int which;
7919c3ed	276	unsigned int reg_addr; /* Unused in this version */
f0ca24b9 JK	277	{
	278	}
	279
	280	#endif /* Not sun386 target. */