[binutils.git] / gdb / i386gnu-nat.c

/* Low level interface to I386 running the GNU Hurd
   Copyright (C) 1992, 1995, 1996 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 "inferior.h"
#include "floatformat.h"

#include <stdio.h>
#include <errno.h>

#include <mach.h>
#include <mach/message.h>
#include <mach/exception.h>
#include <mach_error.h>

#include "gnu-nat.h"

/* Hmmm... Should this not be here?
 * Now for i386_float_info() target_has_execution
 */
#include <target.h>

/* @@@ Should move print_387_status() to i387-tdep.c */
extern void print_387_control_word ();		/* i387-tdep.h */
extern void print_387_status_word ();
\f
/* Find offsets to thread states at compile time.
 * If your compiler does not grok this, calculate offsets
 * offsets yourself and use them (or get a compatible compiler :-)
 */

#define  REG_OFFSET(reg) (int)(&((struct i386_thread_state *)0)->reg)

/* at reg_offset[i] is the offset to the i386_thread_state
 * location where the gdb registers[i] is stored.
 */

static int reg_offset[] = 
{
  REG_OFFSET(eax),  REG_OFFSET(ecx), REG_OFFSET(edx), REG_OFFSET(ebx),
  REG_OFFSET(uesp), REG_OFFSET(ebp), REG_OFFSET(esi), REG_OFFSET(edi),
  REG_OFFSET(eip),  REG_OFFSET(efl), REG_OFFSET(cs),  REG_OFFSET(ss),
  REG_OFFSET(ds),   REG_OFFSET(es),  REG_OFFSET(fs),  REG_OFFSET(gs)
};

#define REG_ADDR(state,regnum) ((char *)(state)+reg_offset[regnum])

/* Fetch COUNT contiguous registers from thread STATE starting from REGNUM
 * Caller knows that the regs handled in one transaction are of same size.
 */
#define FETCH_REGS(state, regnum, count) \
  memcpy (&registers[REGISTER_BYTE (regnum)], \
	  REG_ADDR (state, regnum), \
	  count * REGISTER_RAW_SIZE (regnum))

/* Store COUNT contiguous registers to thread STATE starting from REGNUM */
#define STORE_REGS(state, regnum, count) \
  memcpy (REG_ADDR (state, regnum), \
	  &registers[REGISTER_BYTE (regnum)], \
	  count * REGISTER_RAW_SIZE (regnum))
\f
/*
 * Fetch inferiors registers for gdb.
 * REG specifies which (as gdb views it) register, -1 for all.
 */
void
gnu_fetch_registers (int reg)
{
  struct proc *thread;
  thread_state_t state;
  
  inf_update_procs (current_inferior); /* Make sure we know about new threads.  */

  thread = inf_tid_to_thread (current_inferior, inferior_pid);
  if (! thread)
    error ("fetch inferior registers: %d: Invalid thread", inferior_pid);

  state = proc_get_state (thread, 0);

  if (! state)
    warning ("Couldn't fetch register %s from %s (invalid thread).",
	     reg_names[reg], proc_string (thread));
  else if (reg >= 0)
    {
      proc_debug (thread, "fetching register: %s", reg_names[reg]);
      supply_register (reg, REG_ADDR(state, reg));
      thread->fetched_regs |= (1 << reg);
    }
  else
    {
      proc_debug (thread, "fetching all registers");
      for (reg = 0; reg < NUM_REGS; reg++) 
	supply_register (reg, REG_ADDR(state, reg));
      thread->fetched_regs = ~0;
    }
}
\f
/* Store our register values back into the inferior.
 * If REG is -1, do this for all registers.
 * Otherwise, REG specifies which register
 *
 * On mach3 all registers are always saved in one call.
 */
void
gnu_store_registers (reg)
     int reg;
{
  struct proc *thread;
  int was_aborted, was_valid;
  thread_state_t state;
  thread_state_data_t old_state;
  
  inf_update_procs (current_inferior); /* Make sure we know about new threads.  */

  thread = inf_tid_to_thread (current_inferior, inferior_pid);
  if (! thread)
    error ("store inferior registers: %d: Invalid thread", inferior_pid);

  proc_debug (thread, "storing register %s.", reg_names[reg]);

  was_aborted = thread->aborted;
  was_valid = thread->state_valid;
  if (! was_aborted && was_valid)
    bcopy (&thread->state, &old_state, sizeof (old_state));

  state = proc_get_state (thread, 1);

  if (! state)
    warning ("Couldn't store register %s from %s (invalid thread).",
	     reg_names[reg], proc_string (thread));
  else
    {
      if (! was_aborted && was_valid)
	/* See which registers have changed after aborting the thread.  */
	{
	  int check_reg;
	  for (check_reg = 0; check_reg < NUM_REGS; check_reg++)
	    if ((thread->fetched_regs & (1 << check_reg))
		&& bcmp (REG_ADDR (&old_state, check_reg),
			 REG_ADDR (state, check_reg),
			 REGISTER_RAW_SIZE (check_reg)))
	      /* Register CHECK_REG has changed!  Ack!  */
	      {
		warning ("Register %s changed after thread was aborted.",
			 reg_names [check_reg]);
		if (reg >= 0 && reg != check_reg)
		  /* Update gdb's copy of the register.  */
		  supply_register (check_reg, REG_ADDR (state, check_reg));
		else
		  warning ("... also writing this register!  Suspicious...");
	      }
	}

      if (reg >= 0)
	{
	  proc_debug (thread, "storing register: %s", reg_names[reg]);
	  STORE_REGS (state, reg, 1);
	}
      else
	{
	  proc_debug (thread, "storing all registers");
	  for (reg = 0; reg < NUM_REGS; reg++) 
	    STORE_REGS (state, reg, 1);
	}
    }
}
\f
/* [email protected]: I copied and modified this 387 code from
 * gdb/i386-xdep.c. Modifications for Mach 3.0.
 *
 * i387 status dumper. See also i387-tdep.c
 */
struct env387 
{
  unsigned short control;
  unsigned short r0;
  unsigned short status;
  unsigned short r1;
  unsigned short tag;
  unsigned short r2;
  unsigned long eip;
  unsigned short code_seg;
  unsigned short opcode;
  unsigned long operand;
  unsigned short operand_seg;
  unsigned short r3;
  unsigned char regs[8][10];
};
/* This routine is machine independent?
 * Should move it to i387-tdep.c but you need to export struct env387
 */
static
print_387_status (status, ep)
     unsigned short status;
     struct env387 *ep;
{
  int i;
  int bothstatus;
  int top;
  int fpreg;
  unsigned char *p;
  
  bothstatus = ((status != 0) && (ep->status != 0));
  if (status != 0) 
    {
      if (bothstatus)
	printf_unfiltered ("u: ");
      print_387_status_word (status);
    }
  
  if (ep->status != 0) 
    {
      if (bothstatus)
	printf_unfiltered ("e: ");
      print_387_status_word (ep->status);
    }
  
  print_387_control_word (ep->control);
  printf_unfiltered ("last exception: ");
  printf_unfiltered ("opcode %s; ", local_hex_string(ep->opcode));
  printf_unfiltered ("pc %s:", local_hex_string(ep->code_seg));
  printf_unfiltered ("%s; ", local_hex_string(ep->eip));
  printf_unfiltered ("operand %s", local_hex_string(ep->operand_seg));
  printf_unfiltered (":%s\n", local_hex_string(ep->operand));
  
  top = (ep->status >> 11) & 7;
  
  printf_unfiltered ("regno  tag  msb              lsb  value\n");
  for (fpreg = 7; fpreg >= 0; fpreg--) 
    {
      double val;
      
      printf_unfiltered ("%s %d: ", fpreg == top ? "=>" : "  ", fpreg);
      
      switch ((ep->tag >> (fpreg * 2)) & 3) 
	{
	case 0: printf_unfiltered ("valid "); break;
	case 1: printf_unfiltered ("zero  "); break;
	case 2: printf_unfiltered ("trap  "); break;
	case 3: printf_unfiltered ("empty "); break;
	}
      for (i = 9; i >= 0; i--)
	printf_unfiltered ("%02x", ep->regs[fpreg][i]);
      
      floatformat_to_double (&floatformat_i387_ext, (char *)ep->regs[fpreg],
			       &val);
      printf_unfiltered ("  %g\n", val);
    }
  if (ep->r0)
    printf_unfiltered ("warning: reserved0 is %s\n", local_hex_string(ep->r0));
  if (ep->r1)
    printf_unfiltered ("warning: reserved1 is %s\n", local_hex_string(ep->r1));
  if (ep->r2)
    printf_unfiltered ("warning: reserved2 is %s\n", local_hex_string(ep->r2));
  if (ep->r3)
    printf_unfiltered ("warning: reserved3 is %s\n", local_hex_string(ep->r3));
}
	
/*
 * values that go into fp_kind (from <i386/fpreg.h>)
 */
#define FP_NO   0       /* no fp chip, no emulator (no fp support)      */
#define FP_SW   1       /* no fp chip, using software emulator          */
#define FP_HW   2       /* chip present bit                             */
#define FP_287  2       /* 80287 chip present                           */
#define FP_387  3       /* 80387 chip present                           */

typedef struct fpstate {
#if 1
  unsigned char	state[FP_STATE_BYTES]; /* "hardware" state */
#else
  struct env387	state;	/* Actually this */
#endif
  int status;		/* Duplicate status */
} *fpstate_t;

/* Mach 3 specific routines.
 */
static int
get_i387_state (fstate)
     struct fpstate *fstate;
{
  error_t err;
  thread_state_data_t state;
  unsigned int fsCnt = i386_FLOAT_STATE_COUNT;
  struct i386_float_state *fsp;
  struct proc *thread = inf_tid_to_thread (current_inferior, inferior_pid);
  
  if (!thread)
    error ("get_i387_state: Invalid thread");

  proc_abort (thread, 0);	/* Make sure THREAD's in a reasonable state. */

  err = thread_get_state (thread->port, i386_FLOAT_STATE, state, &fsCnt);
  if (err)
    {
      warning ("Can not get live floating point state: %s",
	       mach_error_string (err));
      return 0;
    }

  fsp = (struct i386_float_state *)state;
  /* The 387 chip (also 486 counts) or a software emulator? */
  if (!fsp->initialized || (fsp->fpkind != FP_387 && fsp->fpkind != FP_SW))
    return 0;

  /* Clear the target then copy thread's float state there.
     Make a copy of the status word, for some reason?
   */
  memset (fstate, 0, sizeof (struct fpstate));

  fstate->status = fsp->exc_status;

  memcpy (fstate->state, (char *)&fsp->hw_state, FP_STATE_BYTES);

  return 1;
}

/*
 * This is called by "info float" command
 */
void
i386_mach3_float_info()
{
  char buf [sizeof (struct fpstate) + 2 * sizeof (int)];
  int valid = 0;
  fpstate_t fps;
  
  if (target_has_execution)
    valid = get_i387_state (buf);

  if (!valid) 
    {
      warning ("no floating point status saved");
      return;
    }
  
  fps = (fpstate_t) buf;

  print_387_status (fps->status, (struct env387 *)fps->state);
}
Commit	Line	Data
ce0787ef	1	/* Low level interface to I386 running the GNU Hurd
647e52ea	2	Copyright (C) 1992, 1995, 1996 Free Software Foundation, Inc.
ce0787ef FF	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, Boston, MA 02111-1307, USA. */
	19
	20	#include "defs.h"
	21	#include "inferior.h"
	22	#include "floatformat.h"
	23
	24	#include <stdio.h>
647e52ea	25	#include <errno.h>
ce0787ef FF	26
	27	#include <mach.h>
	28	#include <mach/message.h>
	29	#include <mach/exception.h>
	30	#include <mach_error.h>
	31
	32	#include "gnu-nat.h"
	33
	34	/* Hmmm... Should this not be here?
	35	* Now for i386_float_info() target_has_execution
	36	*/
	37	#include <target.h>
	38
	39	/* @@@ Should move print_387_status() to i387-tdep.c */
	40	extern void print_387_control_word (); /* i387-tdep.h */
	41	extern void print_387_status_word ();
	42	\f
	43	/* Find offsets to thread states at compile time.
	44	* If your compiler does not grok this, calculate offsets
	45	* offsets yourself and use them (or get a compatible compiler :-)
	46	*/
	47
	48	#define REG_OFFSET(reg) (int)(&((struct i386_thread_state *)0)->reg)
	49
	50	/* at reg_offset[i] is the offset to the i386_thread_state
	51	* location where the gdb registers[i] is stored.
	52	*/
	53
	54	static int reg_offset[] =
	55	{
	56	REG_OFFSET(eax), REG_OFFSET(ecx), REG_OFFSET(edx), REG_OFFSET(ebx),
	57	REG_OFFSET(uesp), REG_OFFSET(ebp), REG_OFFSET(esi), REG_OFFSET(edi),
	58	REG_OFFSET(eip), REG_OFFSET(efl), REG_OFFSET(cs), REG_OFFSET(ss),
	59	REG_OFFSET(ds), REG_OFFSET(es), REG_OFFSET(fs), REG_OFFSET(gs)
	60	};
	61
	62	#define REG_ADDR(state,regnum) ((char *)(state)+reg_offset[regnum])
	63
	64	/* Fetch COUNT contiguous registers from thread STATE starting from REGNUM
	65	* Caller knows that the regs handled in one transaction are of same size.
	66	*/
	67	#define FETCH_REGS(state, regnum, count) \
	68	memcpy (&registers[REGISTER_BYTE (regnum)], \
	69	REG_ADDR (state, regnum), \
	70	count * REGISTER_RAW_SIZE (regnum))
	71
	72	/* Store COUNT contiguous registers to thread STATE starting from REGNUM */
	73	#define STORE_REGS(state, regnum, count) \
	74	memcpy (REG_ADDR (state, regnum), \
	75	&registers[REGISTER_BYTE (regnum)], \
	76	count * REGISTER_RAW_SIZE (regnum))
	77	\f
	78	/*
	79	* Fetch inferiors registers for gdb.
	80	* REG specifies which (as gdb views it) register, -1 for all.
	81	*/
	82	void
	83	gnu_fetch_registers (int reg)
	84	{
647e52ea	85	struct proc *thread;
ce0787ef	86	thread_state_t state;
ce0787ef	87
647e52ea SG	88	inf_update_procs (current_inferior); /* Make sure we know about new threads. */
	89
	90	thread = inf_tid_to_thread (current_inferior, inferior_pid);
	91	if (! thread)
ce0787ef FF	92	error ("fetch inferior registers: %d: Invalid thread", inferior_pid);
	93
	94	state = proc_get_state (thread, 0);
	95
	96	if (! state)
647e52ea SG	97	warning ("Couldn't fetch register %s from %s (invalid thread).",
647e52ea SG	98	reg_names[reg], proc_string (thread));
ce0787ef FF	99	else if (reg >= 0)
	100	{
	101	proc_debug (thread, "fetching register: %s", reg_names[reg]);
	102	supply_register (reg, REG_ADDR(state, reg));
	103	thread->fetched_regs \|= (1 << reg);
	104	}
	105	else
	106	{
	107	proc_debug (thread, "fetching all registers");
	108	for (reg = 0; reg < NUM_REGS; reg++)
	109	supply_register (reg, REG_ADDR(state, reg));
	110	thread->fetched_regs = ~0;
	111	}
	112	}
	113	\f
	114	/* Store our register values back into the inferior.
	115	* If REG is -1, do this for all registers.
	116	* Otherwise, REG specifies which register
	117	*
	118	* On mach3 all registers are always saved in one call.
	119	*/
	120	void
	121	gnu_store_registers (reg)
	122	int reg;
	123	{
647e52ea	124	struct proc *thread;
ce0787ef FF	125	int was_aborted, was_valid;
	126	thread_state_t state;
	127	thread_state_data_t old_state;
647e52ea SG	128
647e52ea SG	129	inf_update_procs (current_inferior); /* Make sure we know about new threads. */
ce0787ef	130
647e52ea	131	thread = inf_tid_to_thread (current_inferior, inferior_pid);
ce0787ef FF	132	if (! thread)
	133	error ("store inferior registers: %d: Invalid thread", inferior_pid);
	134
	135	proc_debug (thread, "storing register %s.", reg_names[reg]);
	136
	137	was_aborted = thread->aborted;
	138	was_valid = thread->state_valid;
	139	if (! was_aborted && was_valid)
	140	bcopy (&thread->state, &old_state, sizeof (old_state));
	141
	142	state = proc_get_state (thread, 1);
	143
	144	if (! state)
647e52ea SG	145	warning ("Couldn't store register %s from %s (invalid thread).",
647e52ea SG	146	reg_names[reg], proc_string (thread));
ce0787ef FF	147	else
	148	{
	149	if (! was_aborted && was_valid)
	150	/* See which registers have changed after aborting the thread. */
	151	{
	152	int check_reg;
	153	for (check_reg = 0; check_reg < NUM_REGS; check_reg++)
	154	if ((thread->fetched_regs & (1 << check_reg))
	155	&& bcmp (REG_ADDR (&old_state, check_reg),
	156	REG_ADDR (state, check_reg),
	157	REGISTER_RAW_SIZE (check_reg)))
	158	/* Register CHECK_REG has changed! Ack! */
	159	{
	160	warning ("Register %s changed after thread was aborted.",
	161	reg_names [check_reg]);
	162	if (reg >= 0 && reg != check_reg)
	163	/* Update gdb's copy of the register. */
	164	supply_register (check_reg, REG_ADDR (state, check_reg));
	165	else
	166	warning ("... also writing this register! Suspicious...");
	167	}
	168	}
	169
	170	if (reg >= 0)
	171	{
	172	proc_debug (thread, "storing register: %s", reg_names[reg]);
	173	STORE_REGS (state, reg, 1);
	174	}
	175	else
	176	{
	177	proc_debug (thread, "storing all registers");
	178	for (reg = 0; reg < NUM_REGS; reg++)
	179	STORE_REGS (state, reg, 1);
	180	}
	181	}
	182	}
	183	\f
	184	/* [email protected]: I copied and modified this 387 code from
	185	* gdb/i386-xdep.c. Modifications for Mach 3.0.
	186	*
	187	* i387 status dumper. See also i387-tdep.c
	188	*/
	189	struct env387
	190	{
	191	unsigned short control;
	192	unsigned short r0;
	193	unsigned short status;
	194	unsigned short r1;
	195	unsigned short tag;
	196	unsigned short r2;
	197	unsigned long eip;
	198	unsigned short code_seg;
	199	unsigned short opcode;
	200	unsigned long operand;
	201	unsigned short operand_seg;
	202	unsigned short r3;
	203	unsigned char regs[8][10];
	204	};
	205	/* This routine is machine independent?
	206	* Should move it to i387-tdep.c but you need to export struct env387
	207	*/
	208	static
	209	print_387_status (status, ep)
	210	unsigned short status;
211	struct env387 *ep;
212	{
213	int i;
214	int bothstatus;
215	int top;
216	int fpreg;
217	unsigned char *p;
218
219	bothstatus = ((status != 0) && (ep->status != 0));
220	if (status != 0)
221	{
222	if (bothstatus)
223	printf_unfiltered ("u: ");
224	print_387_status_word (status);
225	}
226
227	if (ep->status != 0)
228	{
229	if (bothstatus)
230	printf_unfiltered ("e: ");
231	print_387_status_word (ep->status);
232	}
233
234	print_387_control_word (ep->control);
235	printf_unfiltered ("last exception: ");
236	printf_unfiltered ("opcode %s; ", local_hex_string(ep->opcode));
237	printf_unfiltered ("pc %s:", local_hex_string(ep->code_seg));
238	printf_unfiltered ("%s; ", local_hex_string(ep->eip));
239	printf_unfiltered ("operand %s", local_hex_string(ep->operand_seg));
240	printf_unfiltered (":%s\n", local_hex_string(ep->operand));
241
242	top = (ep->status >> 11) & 7;
243
244	printf_unfiltered ("regno tag msb lsb value\n");
245	for (fpreg = 7; fpreg >= 0; fpreg--)
246	{
247	double val;
248
249	printf_unfiltered ("%s %d: ", fpreg == top ? "=>" : " ", fpreg);
250
251	switch ((ep->tag >> (fpreg * 2)) & 3)
252	{
253	case 0: printf_unfiltered ("valid "); break;
254	case 1: printf_unfiltered ("zero "); break;
255	case 2: printf_unfiltered ("trap "); break;
256	case 3: printf_unfiltered ("empty "); break;
257	}
258	for (i = 9; i >= 0; i--)
259	printf_unfiltered ("%02x", ep->regs[fpreg][i]);
260
261	floatformat_to_double (&floatformat_i387_ext, (char *)ep->regs[fpreg],
262	&val);
263	printf_unfiltered (" %g\n", val);
264	}
265	if (ep->r0)
266	printf_unfiltered ("warning: reserved0 is %s\n", local_hex_string(ep->r0));
267	if (ep->r1)
268	printf_unfiltered ("warning: reserved1 is %s\n", local_hex_string(ep->r1));
269	if (ep->r2)
270	printf_unfiltered ("warning: reserved2 is %s\n", local_hex_string(ep->r2));
271	if (ep->r3)
272	printf_unfiltered ("warning: reserved3 is %s\n", local_hex_string(ep->r3));
273	}
274
275	/*
276	* values that go into fp_kind (from <i386/fpreg.h>)
277	*/
278	#define FP_NO 0 /* no fp chip, no emulator (no fp support) */
279	#define FP_SW 1 /* no fp chip, using software emulator */
280	#define FP_HW 2 /* chip present bit */
281	#define FP_287 2 /* 80287 chip present */
282	#define FP_387 3 /* 80387 chip present */
283
284	typedef struct fpstate {
285	#if 1
286	unsigned char state[FP_STATE_BYTES]; /* "hardware" state */
287	#else
288	struct env387 state; /* Actually this */
289	#endif
290	int status; /* Duplicate status */
291	} *fpstate_t;
292
293	/* Mach 3 specific routines.
294	*/
295	static int
296	get_i387_state (fstate)
297	struct fpstate *fstate;
298	{
299	error_t err;
300	thread_state_data_t state;
301	unsigned int fsCnt = i386_FLOAT_STATE_COUNT;
302	struct i386_float_state *fsp;
303	struct proc *thread = inf_tid_to_thread (current_inferior, inferior_pid);
304
305	if (!thread)
306	error ("get_i387_state: Invalid thread");
307
308	proc_abort (thread, 0); /* Make sure THREAD's in a reasonable state. */
309
310	err = thread_get_state (thread->port, i386_FLOAT_STATE, state, &fsCnt);
311	if (err)
312	{
313	warning ("Can not get live floating point state: %s",
314	mach_error_string (err));
315	return 0;
316	}
317
318	fsp = (struct i386_float_state *)state;
319	/* The 387 chip (also 486 counts) or a software emulator? */
320	if (!fsp->initialized \|\| (fsp->fpkind != FP_387 && fsp->fpkind != FP_SW))
321	return 0;
322
323	/* Clear the target then copy thread's float state there.
324	Make a copy of the status word, for some reason?
325	*/
326	memset (fstate, 0, sizeof (struct fpstate));
327
328	fstate->status = fsp->exc_status;
329
330	memcpy (fstate->state, (char *)&fsp->hw_state, FP_STATE_BYTES);
331
332	return 1;
333	}
334
335	/*
336	* This is called by "info float" command
337	*/
338	void
339	i386_mach3_float_info()
340	{
341	char buf [sizeof (struct fpstate) + 2 * sizeof (int)];
342	int valid = 0;
343	fpstate_t fps;
344
345	if (target_has_execution)
346	valid = get_i387_state (buf);
347
348	if (!valid)
349	{
350	warning ("no floating point status saved");
351	return;
352	}
353
354	fps = (fpstate_t) buf;
355
356	print_387_status (fps->status, (struct env387 *)fps->state);
357	}