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

/* Intel 386 stuff.
   Copyright (C) 1988, 1989 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>
#include "defs.h"
#include "param.h"
#include "frame.h"
#include "inferior.h"
#include "gdbcore.h"

#ifdef USG
#include <sys/types.h>
#endif

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

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

#include <sys/reg.h>
\f
/* this table must line up with REGISTER_NAMES in m-i386.h */
/* symbols like 'EAX' come from <sys/reg.h> */
static int regmap[] = 
{
  EAX, ECX, EDX, EBX,
  UESP, EBP, ESI, EDI,
  EIP, EFL, CS, SS,
  DS, ES, FS, GS,
};

/* blockend is the value of u.u_ar0, and points to the
 * place where GS is stored
 */
i386_register_u_addr (blockend, regnum)
{
#if 0
  /* this will be needed if fp registers are reinstated */
  /* for now, you can look at them with 'info float'
   * sys5 wont let you change them with ptrace anyway
   */
  if (regnum >= FP0_REGNUM && regnum <= FP7_REGNUM) 
    {
      int ubase, fpstate;
      struct user u;
      ubase = blockend + 4 * (SS + 1) - KSTKSZ;
      fpstate = ubase + ((char *)&u.u_fpstate - (char *)&u);
      return (fpstate + 0x1c + 10 * (regnum - FP0_REGNUM));
    } 
  else
#endif
    return (blockend + 4 * regmap[regnum]);
  
}

/* This is broken for cross debugging.  Possible solutions are:

1.  Don't worry about whether the thing compiles for cross-debugging.
Go ahead and call them from i386-tdep.c.
1a.  Same thing but use some macros in xm-i386.h so that gdb will
compile for cross-debugging but just give an error (or some such behavior)
when you attempt to convert floats.

2.  Write a portable (in the sense of running on any machine; it would
always be for i387 floating-point formats) extended<->double converter
(which just deals with the values as arrays of char).

3.  Assume the host machine has *some* IEEE chip.  However, IEEE does
not standardize formats for extended floats (387 is 10 bytes, 68881 is
12 bytes), so this won't work.  */

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

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

static
print_387_control_word (control)
unsigned short control;
{
  printf ("control 0x%04x: ", control);
  printf ("compute to ");
  switch ((control >> 8) & 3) 
    {
    case 0: printf ("24 bits; "); break;
    case 1: printf ("(bad); "); break;
    case 2: printf ("53 bits; "); break;
    case 3: printf ("64 bits; "); break;
    }
  printf ("round ");
  switch ((control >> 10) & 3) 
    {
    case 0: printf ("NEAREST; "); break;
    case 1: printf ("DOWN; "); break;
    case 2: printf ("UP; "); break;
    case 3: printf ("CHOP; "); break;
    }
  if (control & 0x3f) 
    {
      printf ("mask:");
      if (control & 0x0001) printf (" INVALID");
      if (control & 0x0002) printf (" DENORM");
      if (control & 0x0004) printf (" DIVZ");
      if (control & 0x0008) printf (" OVERF");
      if (control & 0x0010) printf (" UNDERF");
      if (control & 0x0020) printf (" LOS");
      printf (";");
    }
  printf ("\n");
  if (control & 0xe080) printf ("warning: reserved bits on 0x%x\n",
				control & 0xe080);
}

static
print_387_status_word (status)
     unsigned short status;
{
  printf ("status 0x%04x: ", status);
  if (status & 0xff) 
    {
      printf ("exceptions:");
      if (status & 0x0001) printf (" INVALID");
      if (status & 0x0002) printf (" DENORM");
      if (status & 0x0004) printf (" DIVZ");
      if (status & 0x0008) printf (" OVERF");
      if (status & 0x0010) printf (" UNDERF");
      if (status & 0x0020) printf (" LOS");
      if (status & 0x0040) printf (" FPSTACK");
      printf ("; ");
    }
  printf ("flags: %d%d%d%d; ",
	  (status & 0x4000) != 0,
	  (status & 0x0400) != 0,
	  (status & 0x0200) != 0,
	  (status & 0x0100) != 0);
  
  printf ("top %d\n", (status >> 11) & 7);
}

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 ("u: ");
      print_387_status_word (status);
    }
  
  if (ep->status != 0) 
    {
      if (bothstatus)
	printf ("e: ");
      print_387_status_word (ep->status);
    }
  
  print_387_control_word (ep->control);
  printf ("last exception: ");
  printf ("opcode 0x%x; ", ep->opcode);
  printf ("pc 0x%x:0x%x; ", ep->code_seg, ep->eip);
  printf ("operand 0x%x:0x%x\n", ep->operand_seg, ep->operand);
  
  top = (ep->status >> 11) & 7;
  
  printf ("regno  tag  msb              lsb  value\n");
  for (fpreg = 7; fpreg >= 0; fpreg--) 
    {
      double val;
      
      printf ("%s %d: ", fpreg == top ? "=>" : "  ", fpreg);
      
      switch ((ep->tag >> (fpreg * 2)) & 3) 
	{
	case 0: printf ("valid "); break;
	case 1: printf ("zero  "); break;
	case 2: printf ("trap  "); break;
	case 3: printf ("empty "); break;
	}
      for (i = 9; i >= 0; i--)
	printf ("%02x", ep->regs[fpreg][i]);
      
      i387_to_double (ep->regs[fpreg], (char *)&val);
      printf ("  %g\n", val);
    }
  if (ep->r0)
    printf ("warning: reserved0 is 0x%x\n", ep->r0);
  if (ep->r1)
    printf ("warning: reserved1 is 0x%x\n", ep->r1);
  if (ep->r2)
    printf ("warning: reserved2 is 0x%x\n", ep->r2);
  if (ep->r3)
    printf ("warning: reserved3 is 0x%x\n", ep->r3);
}

#ifndef U_FPSTATE
#define U_FPSTATE(u) u.u_fpstate
#endif

i386_float_info ()
{
  struct user u; /* just for address computations */
  int i;
  /* fpstate defined in <sys/user.h> */
  struct fpstate *fpstatep;
  char buf[sizeof (struct fpstate) + 2 * sizeof (int)];
  unsigned int uaddr;
  char fpvalid;
  unsigned int rounded_addr;
  unsigned int rounded_size;
  extern int corechan;
  int skip;
  
  uaddr = (char *)&u.u_fpvalid - (char *)&u;
  if (have_inferior_p()) 
    {
      unsigned int data;
      unsigned int mask;
      
      rounded_addr = uaddr & -sizeof (int);
      data = ptrace (3, inferior_pid, rounded_addr, 0);
      mask = 0xff << ((uaddr - rounded_addr) * 8);
      
      fpvalid = ((data & mask) != 0);
    } 
  else 
    {
      if (lseek (corechan, uaddr, 0) < 0)
	perror ("seek on core file");
      if (myread (corechan, &fpvalid, 1) < 0) 
	perror ("read on core file");
      
    }
  
  if (fpvalid == 0) 
    {
      printf ("no floating point status saved\n");
      return;
    }
  
  uaddr = (char *)&U_FPSTATE(u) - (char *)&u;
  if (have_inferior_p ()) 
    {
      int *ip;
      
      rounded_addr = uaddr & -sizeof (int);
      rounded_size = (((uaddr + sizeof (struct fpstate)) - uaddr) +
		      sizeof (int) - 1) / sizeof (int);
      skip = uaddr - rounded_addr;
      
      ip = (int *)buf;
      for (i = 0; i < rounded_size; i++) 
	{
	  *ip++ = ptrace (3, inferior_pid, rounded_addr, 0);
	  rounded_addr += sizeof (int);
	}
    } 
  else 
    {
      if (lseek (corechan, uaddr, 0) < 0)
	perror_with_name ("seek on core file");
      if (myread (corechan, buf, sizeof (struct fpstate)) < 0) 
	perror_with_name ("read from core file");
      skip = 0;
    }
  
  fpstatep = (struct fpstate *)(buf + skip);
  print_387_status (fpstatep->status, (struct env387 *)fpstatep->state);
}
Commit	Line	Data
dd3b648e RP	1	/* Intel 386 stuff.
	2	Copyright (C) 1988, 1989 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 JG	17	along with this program; if not, write to the Free Software
99a7de40 JG	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
dd3b648e RP	19
	20	#include <stdio.h>
	21	#include "defs.h"
	22	#include "param.h"
	23	#include "frame.h"
	24	#include "inferior.h"
	25	#include "gdbcore.h"
	26
	27	#ifdef USG
	28	#include <sys/types.h>
	29	#endif
	30
	31	#include <sys/param.h>
	32	#include <sys/dir.h>
	33	#include <signal.h>
	34	#include <sys/user.h>
	35	#include <sys/ioctl.h>
	36	#include <fcntl.h>
	37
	38	#include <sys/file.h>
	39	#include <sys/stat.h>
	40
	41	#include <sys/reg.h>
	42	\f
	43	/* this table must line up with REGISTER_NAMES in m-i386.h */
	44	/* symbols like 'EAX' come from <sys/reg.h> */
	45	static int regmap[] =
	46	{
	47	EAX, ECX, EDX, EBX,
	48	UESP, EBP, ESI, EDI,
	49	EIP, EFL, CS, SS,
	50	DS, ES, FS, GS,
	51	};
	52
	53	/* blockend is the value of u.u_ar0, and points to the
	54	* place where GS is stored
	55	*/
	56	i386_register_u_addr (blockend, regnum)
	57	{
	58	#if 0
	59	/* this will be needed if fp registers are reinstated */
	60	/* for now, you can look at them with 'info float'
	61	* sys5 wont let you change them with ptrace anyway
	62	*/
	63	if (regnum >= FP0_REGNUM && regnum <= FP7_REGNUM)
	64	{
	65	int ubase, fpstate;
	66	struct user u;
	67	ubase = blockend + 4 * (SS + 1) - KSTKSZ;
	68	fpstate = ubase + ((char )&u.u_fpstate - (char )&u);
	69	return (fpstate + 0x1c + 10 * (regnum - FP0_REGNUM));
	70	}
	71	else
	72	#endif
	73	return (blockend + 4 * regmap[regnum]);
	74
	75	}
	76
	77	/* This is broken for cross debugging. Possible solutions are:
	78
	79	1. Don't worry about whether the thing compiles for cross-debugging.
	80	Go ahead and call them from i386-tdep.c.
	81	1a. Same thing but use some macros in xm-i386.h so that gdb will
	82	compile for cross-debugging but just give an error (or some such behavior)
83	when you attempt to convert floats.
84
85	2. Write a portable (in the sense of running on any machine; it would
86	always be for i387 floating-point formats) extended<->double converter
87	(which just deals with the values as arrays of char).
88
89	3. Assume the host machine has some IEEE chip. However, IEEE does
90	not standardize formats for extended floats (387 is 10 bytes, 68881 is
91	12 bytes), so this won't work. */
92
93	i387_to_double (from, to)
94	char *from;
95	char *to;
96	{
97	long *lp;
98	/* push extended mode on 387 stack, then pop in double mode
99	*
100	* first, set exception masks so no error is generated -
101	* number will be rounded to inf or 0, if necessary
102	*/
103	asm ("pushl %eax"); /* grab a stack slot */
104	asm ("fstcw (%esp)"); /* get 387 control word */
105	asm ("movl (%esp),%eax"); /* save old value */
106	asm ("orl $0x3f,%eax"); /* mask all exceptions */
107	asm ("pushl %eax");
108	asm ("fldcw (%esp)"); /* load new value into 387 */
109
110	asm ("movl 8(%ebp),%eax");
111	asm ("fldt (%eax)"); /* push extended number on 387 stack */
112	asm ("fwait");
113	asm ("movl 12(%ebp),%eax");
114	asm ("fstpl (%eax)"); /* pop double */
115	asm ("fwait");
116
117	asm ("popl %eax"); /* flush modified control word */
118	asm ("fnclex"); /* clear exceptions */
119	asm ("fldcw (%esp)"); /* restore original control word */
120	asm ("popl %eax"); /* flush saved copy */
121	}
122
123	double_to_i387 (from, to)
124	char *from;
125	char *to;
126	{
127	/* push double mode on 387 stack, then pop in extended mode
128	* no errors are possible because every 64-bit pattern
129	* can be converted to an extended
130	*/
131	asm ("movl 8(%ebp),%eax");
132	asm ("fldl (%eax)");
133	asm ("fwait");
134	asm ("movl 12(%ebp),%eax");
135	asm ("fstpt (%eax)");
136	asm ("fwait");
137	}
138
139	struct env387
140	{
141	unsigned short control;
142	unsigned short r0;
143	unsigned short status;
144	unsigned short r1;
145	unsigned short tag;
146	unsigned short r2;
147	unsigned long eip;
148	unsigned short code_seg;
149	unsigned short opcode;
150	unsigned long operand;
151	unsigned short operand_seg;
152	unsigned short r3;
153	unsigned char regs[8][10];
154	};
155
156	static
157	print_387_control_word (control)
158	unsigned short control;
159	{
160	printf ("control 0x%04x: ", control);
161	printf ("compute to ");
162	switch ((control >> 8) & 3)
163	{
164	case 0: printf ("24 bits; "); break;
165	case 1: printf ("(bad); "); break;
166	case 2: printf ("53 bits; "); break;
167	case 3: printf ("64 bits; "); break;
168	}
169	printf ("round ");
170	switch ((control >> 10) & 3)
171	{
172	case 0: printf ("NEAREST; "); break;
173	case 1: printf ("DOWN; "); break;
174	case 2: printf ("UP; "); break;
175	case 3: printf ("CHOP; "); break;
176	}
177	if (control & 0x3f)
178	{
179	printf ("mask:");
180	if (control & 0x0001) printf (" INVALID");
181	if (control & 0x0002) printf (" DENORM");
182	if (control & 0x0004) printf (" DIVZ");
183	if (control & 0x0008) printf (" OVERF");
184	if (control & 0x0010) printf (" UNDERF");
185	if (control & 0x0020) printf (" LOS");
186	printf (";");
187	}
188	printf ("\n");
189	if (control & 0xe080) printf ("warning: reserved bits on 0x%x\n",
190	control & 0xe080);
191	}
192
193	static
194	print_387_status_word (status)
195	unsigned short status;
196	{
197	printf ("status 0x%04x: ", status);
198	if (status & 0xff)
199	{
200	printf ("exceptions:");
201	if (status & 0x0001) printf (" INVALID");
202	if (status & 0x0002) printf (" DENORM");
203	if (status & 0x0004) printf (" DIVZ");
204	if (status & 0x0008) printf (" OVERF");
205	if (status & 0x0010) printf (" UNDERF");
206	if (status & 0x0020) printf (" LOS");
207	if (status & 0x0040) printf (" FPSTACK");
208	printf ("; ");
209	}
210	printf ("flags: %d%d%d%d; ",
211	(status & 0x4000) != 0,
212	(status & 0x0400) != 0,
213	(status & 0x0200) != 0,
214	(status & 0x0100) != 0);
215
216	printf ("top %d\n", (status >> 11) & 7);
217	}
218
219	static
220	print_387_status (status, ep)
221	unsigned short status;
222	struct env387 *ep;
223	{
224	int i;
225	int bothstatus;
226	int top;
227	int fpreg;
228	unsigned char *p;
229
230	bothstatus = ((status != 0) && (ep->status != 0));
231	if (status != 0)
232	{
233	if (bothstatus)
234	printf ("u: ");
235	print_387_status_word (status);
236	}
237
238	if (ep->status != 0)
239	{
240	if (bothstatus)
241	printf ("e: ");
242	print_387_status_word (ep->status);
243	}
244
245	print_387_control_word (ep->control);
246	printf ("last exception: ");
247	printf ("opcode 0x%x; ", ep->opcode);
248	printf ("pc 0x%x:0x%x; ", ep->code_seg, ep->eip);
249	printf ("operand 0x%x:0x%x\n", ep->operand_seg, ep->operand);
250
251	top = (ep->status >> 11) & 7;
252
253	printf ("regno tag msb lsb value\n");
254	for (fpreg = 7; fpreg >= 0; fpreg--)
255	{
256	double val;
257
258	printf ("%s %d: ", fpreg == top ? "=>" : " ", fpreg);
259
260	switch ((ep->tag >> (fpreg * 2)) & 3)
261	{
262	case 0: printf ("valid "); break;
263	case 1: printf ("zero "); break;
264	case 2: printf ("trap "); break;
265	case 3: printf ("empty "); break;
266	}
267	for (i = 9; i >= 0; i--)
268	printf ("%02x", ep->regs[fpreg][i]);
269
270	i387_to_double (ep->regs[fpreg], (char *)&val);
271	printf (" %g\n", val);
272	}
273	if (ep->r0)
274	printf ("warning: reserved0 is 0x%x\n", ep->r0);
275	if (ep->r1)
276	printf ("warning: reserved1 is 0x%x\n", ep->r1);
277	if (ep->r2)
278	printf ("warning: reserved2 is 0x%x\n", ep->r2);
279	if (ep->r3)
280	printf ("warning: reserved3 is 0x%x\n", ep->r3);
281	}
282
283	#ifndef U_FPSTATE
284	#define U_FPSTATE(u) u.u_fpstate
285	#endif
286
287	i386_float_info ()
288	{
289	struct user u; /* just for address computations */
290	int i;
291	/* fpstate defined in <sys/user.h> */
292	struct fpstate *fpstatep;
293	char buf[sizeof (struct fpstate) + 2 * sizeof (int)];
294	unsigned int uaddr;
295	char fpvalid;
296	unsigned int rounded_addr;
297	unsigned int rounded_size;
298	extern int corechan;
299	int skip;
300
301	uaddr = (char )&u.u_fpvalid - (char )&u;
302	if (have_inferior_p())
303	{
304	unsigned int data;
305	unsigned int mask;
306
307	rounded_addr = uaddr & -sizeof (int);
308	data = ptrace (3, inferior_pid, rounded_addr, 0);
309	mask = 0xff << ((uaddr - rounded_addr) * 8);
310
311	fpvalid = ((data & mask) != 0);
312	}
313	else
314	{
315	if (lseek (corechan, uaddr, 0) < 0)
316	perror ("seek on core file");
317	if (myread (corechan, &fpvalid, 1) < 0)
318	perror ("read on core file");
319
320	}
321
322	if (fpvalid == 0)
323	{
324	printf ("no floating point status saved\n");
325	return;
326	}
327
328	uaddr = (char )&U_FPSTATE(u) - (char )&u;
329	if (have_inferior_p ())
330	{
331	int *ip;
332
333	rounded_addr = uaddr & -sizeof (int);
334	rounded_size = (((uaddr + sizeof (struct fpstate)) - uaddr) +
335	sizeof (int) - 1) / sizeof (int);
336	skip = uaddr - rounded_addr;
337
338	ip = (int *)buf;
339	for (i = 0; i < rounded_size; i++)
340	{
341	*ip++ = ptrace (3, inferior_pid, rounded_addr, 0);
342	rounded_addr += sizeof (int);
343	}
344	}
345	else
346	{
347	if (lseek (corechan, uaddr, 0) < 0)
348	perror_with_name ("seek on core file");
349	if (myread (corechan, buf, sizeof (struct fpstate)) < 0)
350	perror_with_name ("read from core file");
351	skip = 0;
352	}
353
354	fpstatep = (struct fpstate *)(buf + skip);
355	print_387_status (fpstatep->status, (struct env387 *)fpstatep->state);
356	}
357