Merge from vendor branch LIBSTDC++:
[dragonfly.git] / gnu / usr.bin / binutils / gdb / i386 / freebsd-nat.c
1 /* $FreeBSD: src/gnu/usr.bin/binutils/gdb/i386/freebsd-nat.c,v 1.21.4.4 2001/08/15 02:42:27 peter Exp $ */
2 /* $DragonFly: src/gnu/usr.bin/binutils/gdb/i386/Attic/freebsd-nat.c,v 1.3 2003/07/13 07:13:51 dillon Exp $ */
3 /* Native-dependent code for BSD Unix running on i386's, for GDB.
4    Copyright 1988, 1989, 1991, 1992, 1994, 1996 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
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
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
22 #include "defs.h"
23
24 #include <sys/types.h>
25 #include <sys/ptrace.h>
26 #include <machine/reg.h>
27 #include <machine/frame.h>
28 #include <sys/param.h>
29 #include <sys/user.h>
30 #include "gdbcore.h"
31 #include "value.h"
32 #include "inferior.h"
33
34 #if defined(HAVE_GREGSET_T) || defined(HAVE_FPREGSET_T)
35 #include <sys/procfs.h>
36 #endif
37
38 #define PCB_OFFSET (UPAGES * PAGE_SIZE - sizeof(struct pcb))
39
40 /* this table must line up with REGISTER_NAMES in tm-i386v.h */
41 /* symbols like 'tEAX' come from <machine/reg.h> */
42 static int tregmap[] =
43 {
44   tEAX, tECX, tEDX, tEBX,
45   tESP, tEBP, tESI, tEDI,
46   tEIP, tEFLAGS, tCS, tSS,
47   tDS, tES, tFS, tGS,
48 };
49
50 static struct save87 pcb_savefpu;
51
52 void
53 fetch_inferior_registers (regno)
54      int regno;
55 {
56   struct reg inferior_registers;        /* ptrace order, not gcc/gdb order */
57   int r;
58
59   ptrace (PT_GETREGS, inferior_pid,
60           (PTRACE_ARG3_TYPE) &inferior_registers, 0);
61
62   for (r = 0; r < NUM_REGS; r++)
63     memcpy (&registers[REGISTER_BYTE (r)], ((int *)&inferior_registers) + tregmap[r], 4);
64
65   registers_fetched ();
66 }
67
68 void
69 store_inferior_registers (regno)
70      int regno;
71 {
72   struct reg inferior_registers;        /* ptrace order, not gcc/gdb order */
73   int r;
74
75   for (r = 0; r < NUM_REGS; r++)
76     memcpy (((int *)&inferior_registers) + tregmap[r], &registers[REGISTER_BYTE (r)], 4);
77
78   ptrace (PT_SETREGS, inferior_pid,
79           (PTRACE_ARG3_TYPE) &inferior_registers, 0);
80 }
81
82 /* Extract the register values out of the core file and store
83    them where `read_register' will find them.
84    Extract the floating point state out of the core file and store
85    it where `float_info' will find it.
86
87    CORE_REG_SECT points to the register values themselves, read into memory.
88    CORE_REG_SIZE is the size of that area.
89    WHICH says which set of registers we are handling (0 = int, 2 = float
90          on machines where they are discontiguous).
91    REG_ADDR is the offset from u.u_ar0 to the register values relative to
92             core_reg_sect.  This is used with old-fashioned core files to
93             locate the registers in a large upage-plus-stack ".reg" section.
94             Original upage address X is at location core_reg_sect+x+reg_addr.
95  */
96
97 static void
98 fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
99      char *core_reg_sect;
100      unsigned core_reg_size;
101      int which;
102      CORE_ADDR reg_addr;
103 {
104   register int regno;
105   register int cregno;
106   register int addr;
107   int bad_reg = -1;
108   int offset;
109   struct user *tmp_uaddr;
110
111   /* 
112    * First get virtual address of user structure. Then calculate offset.
113    */
114
115   memcpy(&tmp_uaddr,
116          &((struct user *) core_reg_sect)->u_kproc.kp_proc.p_addr,
117          sizeof(tmp_uaddr));
118   offset = -reg_addr - (int) tmp_uaddr;
119   
120   for (regno = 0; regno < NUM_REGS; regno++)
121     {
122       cregno = tregmap[regno];
123       if (cregno == tGS)
124         addr = PCB_OFFSET + offsetof (struct pcb, pcb_gs);
125       else
126         addr = offset + 4 * cregno;
127       if (addr < 0 || addr >= core_reg_size)
128         {
129           if (bad_reg < 0)
130             bad_reg = regno;
131         }
132       else
133         {
134           supply_register (regno, core_reg_sect + addr);
135         }
136     }
137   if (bad_reg >= 0)
138     {
139       error ("Register %s not found in core file.", gdb_register_names[bad_reg]);
140     }
141
142 #if __FreeBSD_version >= 440000
143   addr = PCB_OFFSET + offsetof (struct pcb, pcb_save);
144 #else
145   addr = PCB_OFFSET + offsetof (struct pcb, pcb_savefpu);
146 #endif
147   memcpy (&pcb_savefpu, core_reg_sect + addr, sizeof pcb_savefpu);
148 }
149
150 #ifdef FLOAT_INFO
151 #include "expression.h"
152 #include "language.h"                   /* for local_hex_string */
153 #include "floatformat.h"
154
155 #include <sys/param.h>
156 #include <signal.h>
157 #include <sys/ioctl.h>
158 #include <fcntl.h>
159
160 #include <a.out.h>
161
162 #include <sys/time.h>
163 #include <sys/resource.h>
164 #include <sys/uio.h>
165 #define curpcb Xcurpcb  /* XXX avoid leaking declaration from pcb.h */
166 #include <sys/user.h>
167 #undef curpcb
168 #include <sys/file.h>
169 #include "gdb_stat.h"
170 #include <sys/ptrace.h>
171
172 extern void print_387_control_word ();          /* i387-tdep.h */
173 extern void print_387_status_word ();
174
175 #define fpstate         save87
176 #if __FreeBSD_version >= 440000
177 #define U_FPSTATE(u)    (((struct pcb *)((char *)&u + PCB_OFFSET))->pcb_save.sv_87)
178 #else
179 #define U_FPSTATE(u)    (((struct pcb *)((char *)&u + PCB_OFFSET))->pcb_savefpu)
180 #endif
181
182 static void
183 i387_to_double (from, to)
184      char *from;
185      char *to;
186 {
187   long *lp;
188   /* push extended mode on 387 stack, then pop in double mode
189    *
190    * first, set exception masks so no error is generated -
191    * number will be rounded to inf or 0, if necessary
192    */
193   asm ("pushl %eax");           /* grab a stack slot */
194   asm ("fstcw (%esp)");         /* get 387 control word */
195   asm ("movl (%esp),%eax");     /* save old value */
196   asm ("orl $0x3f,%eax");               /* mask all exceptions */
197   asm ("pushl %eax");
198   asm ("fldcw (%esp)");         /* load new value into 387 */
199
200   asm ("movl 8(%ebp),%eax");
201   asm ("fldt (%eax)");          /* push extended number on 387 stack */
202   asm ("fwait");
203   asm ("movl 12(%ebp),%eax");
204   asm ("fstpl (%eax)");         /* pop double */
205   asm ("fwait");
206
207   asm ("popl %eax");            /* flush modified control word */
208   asm ("fnclex");                       /* clear exceptions */
209   asm ("fldcw (%esp)");         /* restore original control word */
210   asm ("popl %eax");            /* flush saved copy */
211 }
212
213 struct env387 
214 {
215   unsigned short control;
216   unsigned short r0;
217   unsigned short status;
218   unsigned short r1;
219   unsigned short tag;
220   unsigned short r2;
221   unsigned long eip;
222   unsigned short code_seg;
223   unsigned short opcode;
224   unsigned long operand;
225   unsigned short operand_seg;
226   unsigned short r3;
227   unsigned char regs[8][10];
228 };
229
230 static void
231 print_387_status (status, ep)
232      unsigned short status;
233      struct env387 *ep;
234 {
235   int i;
236   int bothstatus;
237   int top;
238   int fpreg;
239   
240   bothstatus = ((status != 0) && (ep->status != 0));
241   if (status != 0) 
242     {
243       if (bothstatus)
244         printf_unfiltered ("u: ");
245       print_387_status_word ((unsigned int)status);
246     }
247   
248   if (ep->status != 0) 
249     {
250       if (bothstatus)
251         printf_unfiltered ("e: ");
252       print_387_status_word ((unsigned int)ep->status);
253     }
254   
255   print_387_control_word ((unsigned int)ep->control);
256   printf_unfiltered ("last instruction: ");
257   printf_unfiltered ("opcode %s; ", local_hex_string(ep->opcode));
258   printf_unfiltered ("pc %s:", local_hex_string(ep->code_seg));
259   printf_unfiltered ("%s; ", local_hex_string(ep->eip));
260   printf_unfiltered ("operand %s", local_hex_string(ep->operand_seg));
261   printf_unfiltered (":%s\n", local_hex_string(ep->operand));
262
263   top = (ep->status >> 11) & 7;
264   
265   printf_unfiltered (" regno     tag  msb              lsb  value\n");
266   for (fpreg = 7; fpreg >= 0; fpreg--) 
267     {
268       int exp;
269       int mantissa_or;
270       int normal;
271       char *sign;
272       int st_regno;
273       unsigned short *usregs;
274       double val;
275       
276       /* The physical regno `fpreg' is only relevant as an index into the
277        * tag word.  Logical `%st' numbers are required for indexing ep->regs.
278        */
279       st_regno = (fpreg + 8 - top) & 7;
280
281       printf_unfiltered ("%%st(%d) %s ", st_regno, fpreg == top ? "=>" : "  ");
282
283       switch ((ep->tag >> (fpreg * 2)) & 3) 
284         {
285         case 0: printf_unfiltered ("valid "); break;
286         case 1: printf_unfiltered ("zero  "); break;
287         case 2: printf_unfiltered ("trap  "); break;
288         case 3: printf_unfiltered ("empty "); break;
289         }
290       for (i = 9; i >= 0; i--)
291         printf_unfiltered ("%02x", ep->regs[st_regno][i]);
292       
293       printf_unfiltered ("  ");
294
295       /*
296        * Handle weird cases better than floatformat_to_double () and
297        * printf ().
298        */
299       usregs = (unsigned short *) ep->regs[st_regno];
300       sign = usregs[4] & 0x8000 ? "-" : "";
301       exp = usregs[4] & 0x7fff;
302       normal = usregs[3] & 0x8000;
303       mantissa_or = usregs[0] | usregs[1] | usregs[2] | (usregs[3] & 0x7fff);
304       if (exp == 0)
305         {
306           if (normal)
307             printf_unfiltered ("Pseudo Denormal (0 as a double)");
308           else if (mantissa_or == 0)
309             printf_unfiltered ("%s0", sign);
310           else
311             printf_unfiltered ("Denormal (0 as a double)");
312         }
313       else if (exp == 0x7fff)
314         {
315           if (!normal)
316             printf_unfiltered ("Pseudo ");
317           if (mantissa_or == 0)
318             printf_unfiltered ("%sInf", sign);
319           else
320             printf_unfiltered ("%s NaN",
321                                usregs[3] & 0x4000 ? "Quiet" : "Signaling");
322           if (!normal)
323             printf_unfiltered (" (NaN)");
324         }
325       else if (!normal)
326         printf_unfiltered ("Unnormal (NaN)");
327       else
328         {
329 #if 0
330           /* Use this we stop trapping on overflow.  */
331           floatformat_to_double(&floatformat_i387_ext,
332                                 (char *) ep->regs[st_regno], &val);
333 #else
334           i387_to_double((char *) ep->regs[st_regno], (char *) &val);
335 #endif
336           printf_unfiltered ("%g", val);
337         }
338       printf_unfiltered ("\n");
339     }
340 }
341
342 void
343 i386_float_info ()
344 {
345   struct user u; /* just for address computations */
346   int i;
347   /* fpstate defined in <sys/user.h> */
348   struct fpstate *fpstatep;
349   char buf[sizeof (struct fpstate) + 2 * sizeof (int)];
350   unsigned int uaddr;
351   char fpvalid;
352   unsigned int rounded_addr;
353   unsigned int rounded_size;
354   /*extern int corechan;*/
355   int skip;
356   extern int inferior_pid;
357   
358   uaddr = (char *)&U_FPSTATE(u) - (char *)&u;
359   if (inferior_pid != 0 && core_bfd == NULL) 
360     {
361       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
362       ptrace(PT_GETFPREGS, pid, &buf[0], sizeof(struct fpreg));
363       fpstatep = (struct fpstate *)&buf[0];
364     } 
365   else 
366     fpstatep = &pcb_savefpu;
367
368   print_387_status (fpstatep->sv_ex_sw, (struct env387 *)fpstatep);
369 }
370 #endif /* FLOAT_INFO */
371
372 int
373 kernel_u_size ()
374 {
375   return (sizeof (struct user));
376 }
377
378 #ifdef  SETUP_ARBITRARY_FRAME
379 #include "frame.h"
380 struct frame_info *
381 setup_arbitrary_frame (argc, argv)
382         int argc;
383         CORE_ADDR *argv;
384 {
385     if (argc != 2)
386         error ("i386 frame specifications require two arguments: sp and pc");
387
388     return create_new_frame (argv[0], argv[1]);
389 }
390 #endif  /* SETUP_ARBITRARY_FRAME */
391
392 #ifdef HAVE_GREGSET_T
393 void
394 supply_gregset (gp)
395   gregset_t *gp;
396 {
397   int regno = 0;
398
399   /* These must be ordered the same as REGISTER_NAMES in
400      config/i386/tm-i386.h. */
401   supply_register (regno++, (char *)&gp->r_eax);
402   supply_register (regno++, (char *)&gp->r_ecx);
403   supply_register (regno++, (char *)&gp->r_edx);
404   supply_register (regno++, (char *)&gp->r_ebx);
405   supply_register (regno++, (char *)&gp->r_esp);
406   supply_register (regno++, (char *)&gp->r_ebp);
407   supply_register (regno++, (char *)&gp->r_esi);
408   supply_register (regno++, (char *)&gp->r_edi);
409   supply_register (regno++, (char *)&gp->r_eip);
410   supply_register (regno++, (char *)&gp->r_eflags);
411   supply_register (regno++, (char *)&gp->r_cs);
412   supply_register (regno++, (char *)&gp->r_ss);
413   supply_register (regno++, (char *)&gp->r_ds);
414   supply_register (regno++, (char *)&gp->r_es);
415   supply_register (regno++, (char *)&gp->r_fs);
416   supply_register (regno++, (char *)&gp->r_gs);
417 }
418 #endif  /* HAVE_GREGSET_T */
419
420 #ifdef HAVE_FPREGSET_T
421 void
422 supply_fpregset (fp)
423   fpregset_t *fp;
424 {
425   memcpy (&pcb_savefpu, fp, sizeof pcb_savefpu);
426 }
427 #endif  /* HAVE_FPREGSET_T */
428 \f
429 /* Register that we are able to handle aout (trad-core) file formats.  */
430
431 static struct core_fns aout_core_fns =
432 {
433   bfd_target_unknown_flavour,
434   fetch_core_registers,
435   NULL
436 };
437
438 void
439 _initialize_core_aout ()
440 {
441   add_core_fns (&aout_core_fns);
442 }
443
444 #ifdef PT_GETDBREGS
445
446 /*
447  * 0: no trace output
448  * 1: trace watchpoint requests
449  * 2: trace `watchpoint hit?' tests, too
450  */
451 #define WATCHPOINT_DEBUG 0
452
453 #include "breakpoint.h"
454
455 int
456 can_watch(type, cnt, ot)
457      int type, cnt, ot;
458 {
459   int rv;
460   static int cnt_watch, cnt_awatch;
461
462   switch (type)
463     {
464     case bp_hardware_watchpoint:
465       cnt_watch = cnt;
466       break;
467       
468     case bp_access_watchpoint:
469       cnt_awatch = cnt;
470       break;
471       
472     default:
473       rv = 0;
474       goto overandout;
475     }
476
477   rv = cnt_watch + cnt_awatch <= 4? 1: -1;
478
479  overandout:
480 #if WATCHPOINT_DEBUG
481   printf_filtered("can_watch(%d, %d, %d) = %d (counts: w: %d, rw: %d)\n",
482                   type, cnt, ot, rv, cnt_watch, cnt_awatch);
483 #endif
484
485   return rv;
486 }
487
488 int
489 stopped_by_watchpoint()
490 {
491   struct dbreg dbr;
492   extern int inferior_pid;
493
494   if (current_target.to_shortname == 0 ||
495       ! (strcmp(current_target.to_shortname, "child") == 0 ||
496          strcmp(current_target.to_shortname, "freebsd-uthreads") == 0))
497     return 0;
498   
499   if (inferior_pid != 0 && core_bfd == NULL) 
500     {
501       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
502   
503       if (ptrace(PT_GETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
504         {
505           perror("ptrace(PT_GETDBREGS) failed");
506           return 0;
507         }
508 #if WATCHPOINT_DEBUG > 1
509       printf_filtered("stopped_by_watchpoint(): DR6 = %#x\n", dbr.dr6);
510 #endif
511       /*
512        * If a hardware watchpoint was hit, one of the lower 4 bits in
513        * DR6 is set (the actual bit indicates which of DR0...DR3 triggered
514        * the trap).
515        */
516       return dbr.dr6 & 0x0f;
517     } 
518   else
519     {
520       warning("Can't set a watchpoint on a core file.");
521       return 0;
522     }
523 }
524
525 int
526 insert_watchpoint(addr, len, type)
527      int addr, len, type;
528 {
529   struct dbreg dbr;
530   extern int inferior_pid;
531   
532   if (current_target.to_shortname == 0 ||
533       ! (strcmp(current_target.to_shortname, "child") == 0 ||
534          strcmp(current_target.to_shortname, "freebsd-uthreads") == 0))
535     return 0;
536   
537   if (inferior_pid != 0 && core_bfd == NULL) 
538     {
539       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
540       int i, mask;
541       unsigned int sbits;
542
543       if (ptrace(PT_GETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
544         {
545           perror("ptrace(PT_GETDBREGS) failed");
546           return 0;
547         }
548
549       for (i = 0, mask = 0x03; i < 4; i++, mask <<= 2)
550         if ((dbr.dr7 & mask) == 0)
551           break;
552       if (i >= 4) {
553         warning("no more hardware watchpoints available");
554         return -1;
555       }
556
557       /* paranoia */
558       if (len > 4)
559         {
560           warning("watchpoint length %d unsupported, using lenght = 4",
561                   len);
562           len = 4;
563         }
564       else if (len == 3)
565         {
566           warning("weird watchpoint length 3, using 2");
567           len = 2;
568         }
569       else if (len == 0)
570         {
571           warning("weird watchpoint length 0, using 1");
572           len = 1;
573         }
574
575       switch (len)
576         {
577         case 1: sbits = 0; break;
578         case 2: sbits = 4; break;
579         case 4: sbits = 0x0c; break;
580         }
581       
582       /*
583        *  The `type' value is 0 for `watch on write', 1 for `watch on
584        * read', 2 for `watch on both'.  The i386 debug register
585        * breakpoint types are 0 for `execute' (not used in GDB), 1 for
586        * `write', and 4 for `read/write'.  Plain `read' trapping is
587        * not supported on i386, value 3 is illegal.
588        */
589       switch (type)
590         {
591         default:
592           warning("weird watchpoint type %d, using a write watchpoint");
593           /* FALLTHROUGH */
594         case 0:
595           sbits |= 1;
596           break;
597
598         case 2:
599           sbits |= 3;
600           break;
601         }
602       sbits <<= 4 * i + 16;
603       sbits |= 1 << 2 * i;
604
605       dbr.dr7 |= sbits;
606       *(&dbr.dr0 + i) = (unsigned int)addr;
607
608 #if WATCHPOINT_DEBUG
609       printf_filtered("insert_watchpoint(), inserting DR7 = %#x, DR%d = %#x\n",
610                       dbr.dr7, i, addr);
611 #endif
612       if (ptrace(PT_SETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
613         {
614           perror("ptrace(PT_SETDBREGS) failed");
615           return 0;
616         }
617     }
618   else
619     {
620       warning("Can't set a watchpoint on a core file.");
621       return 0;
622     }
623 }
624
625 int
626 remove_watchpoint(addr, len, type)
627      int addr, len, type;
628 {
629   struct dbreg dbr;
630   extern int inferior_pid;
631   
632   if (current_target.to_shortname == 0 ||
633       ! (strcmp(current_target.to_shortname, "child") == 0 ||
634          strcmp(current_target.to_shortname, "freebsd-uthreads") == 0))
635     return 0;
636
637   if (inferior_pid != 0 && core_bfd == NULL) 
638     {
639       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
640       int i;
641       unsigned int sbits, *dbregp;
642   
643       if (ptrace(PT_GETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
644         {
645           perror("ptrace(PT_GETDBREGS) failed");
646           return 0;
647         }
648
649       for (i = 0, dbregp = &dbr.dr0; i < 4; i++, dbregp++)
650         if (*dbregp == (unsigned int)addr)
651           break;
652       if (i >= 4)
653         {
654           warning("watchpoint for address %#x not found", addr);
655           return -1;
656         }
657
658       *dbregp = 0;
659       sbits = 0xf << (4 * i + 16);
660       sbits |= 3 << 2 * i;
661       dbr.dr7 &= ~sbits;
662
663 #if WATCHPOINT_DEBUG
664       printf_filtered("remove_watchpoint(): removing watchpoint for %#x, DR7 = %#x\n",
665                       addr, dbr.dr7);
666 #endif
667       if (ptrace(PT_SETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
668         {
669           perror("ptrace(PT_SETDBREGS) failed");
670           return 0;
671         }
672     }
673   else
674     {
675       warning("Can't set a watchpoint on a core file.");
676       return 0;
677     }
678 }
679
680 #endif /* PT_GETDBREGS */