More __FreeBSD__ -> __DragonFly__ translation
[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.4 2004/02/03 19:22:53 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   addr = PCB_OFFSET + offsetof (struct pcb, pcb_save);
143   memcpy (&pcb_savefpu, core_reg_sect + addr, sizeof pcb_savefpu);
144 }
145
146 #ifdef FLOAT_INFO
147 #include "expression.h"
148 #include "language.h"                   /* for local_hex_string */
149 #include "floatformat.h"
150
151 #include <sys/param.h>
152 #include <signal.h>
153 #include <sys/ioctl.h>
154 #include <fcntl.h>
155
156 #include <a.out.h>
157
158 #include <sys/time.h>
159 #include <sys/resource.h>
160 #include <sys/uio.h>
161 #define curpcb Xcurpcb  /* XXX avoid leaking declaration from pcb.h */
162 #include <sys/user.h>
163 #undef curpcb
164 #include <sys/file.h>
165 #include "gdb_stat.h"
166 #include <sys/ptrace.h>
167
168 extern void print_387_control_word ();          /* i387-tdep.h */
169 extern void print_387_status_word ();
170
171 #define fpstate         save87
172 #if __FreeBSD_version >= 440000
173 #define U_FPSTATE(u)    (((struct pcb *)((char *)&u + PCB_OFFSET))->pcb_save.sv_87)
174 #else
175 #define U_FPSTATE(u)    (((struct pcb *)((char *)&u + PCB_OFFSET))->pcb_savefpu)
176 #endif
177
178 static void
179 i387_to_double (from, to)
180      char *from;
181      char *to;
182 {
183   long *lp;
184   /* push extended mode on 387 stack, then pop in double mode
185    *
186    * first, set exception masks so no error is generated -
187    * number will be rounded to inf or 0, if necessary
188    */
189   asm ("pushl %eax");           /* grab a stack slot */
190   asm ("fstcw (%esp)");         /* get 387 control word */
191   asm ("movl (%esp),%eax");     /* save old value */
192   asm ("orl $0x3f,%eax");               /* mask all exceptions */
193   asm ("pushl %eax");
194   asm ("fldcw (%esp)");         /* load new value into 387 */
195
196   asm ("movl 8(%ebp),%eax");
197   asm ("fldt (%eax)");          /* push extended number on 387 stack */
198   asm ("fwait");
199   asm ("movl 12(%ebp),%eax");
200   asm ("fstpl (%eax)");         /* pop double */
201   asm ("fwait");
202
203   asm ("popl %eax");            /* flush modified control word */
204   asm ("fnclex");                       /* clear exceptions */
205   asm ("fldcw (%esp)");         /* restore original control word */
206   asm ("popl %eax");            /* flush saved copy */
207 }
208
209 struct env387 
210 {
211   unsigned short control;
212   unsigned short r0;
213   unsigned short status;
214   unsigned short r1;
215   unsigned short tag;
216   unsigned short r2;
217   unsigned long eip;
218   unsigned short code_seg;
219   unsigned short opcode;
220   unsigned long operand;
221   unsigned short operand_seg;
222   unsigned short r3;
223   unsigned char regs[8][10];
224 };
225
226 static void
227 print_387_status (status, ep)
228      unsigned short status;
229      struct env387 *ep;
230 {
231   int i;
232   int bothstatus;
233   int top;
234   int fpreg;
235   
236   bothstatus = ((status != 0) && (ep->status != 0));
237   if (status != 0) 
238     {
239       if (bothstatus)
240         printf_unfiltered ("u: ");
241       print_387_status_word ((unsigned int)status);
242     }
243   
244   if (ep->status != 0) 
245     {
246       if (bothstatus)
247         printf_unfiltered ("e: ");
248       print_387_status_word ((unsigned int)ep->status);
249     }
250   
251   print_387_control_word ((unsigned int)ep->control);
252   printf_unfiltered ("last instruction: ");
253   printf_unfiltered ("opcode %s; ", local_hex_string(ep->opcode));
254   printf_unfiltered ("pc %s:", local_hex_string(ep->code_seg));
255   printf_unfiltered ("%s; ", local_hex_string(ep->eip));
256   printf_unfiltered ("operand %s", local_hex_string(ep->operand_seg));
257   printf_unfiltered (":%s\n", local_hex_string(ep->operand));
258
259   top = (ep->status >> 11) & 7;
260   
261   printf_unfiltered (" regno     tag  msb              lsb  value\n");
262   for (fpreg = 7; fpreg >= 0; fpreg--) 
263     {
264       int exp;
265       int mantissa_or;
266       int normal;
267       char *sign;
268       int st_regno;
269       unsigned short *usregs;
270       double val;
271       
272       /* The physical regno `fpreg' is only relevant as an index into the
273        * tag word.  Logical `%st' numbers are required for indexing ep->regs.
274        */
275       st_regno = (fpreg + 8 - top) & 7;
276
277       printf_unfiltered ("%%st(%d) %s ", st_regno, fpreg == top ? "=>" : "  ");
278
279       switch ((ep->tag >> (fpreg * 2)) & 3) 
280         {
281         case 0: printf_unfiltered ("valid "); break;
282         case 1: printf_unfiltered ("zero  "); break;
283         case 2: printf_unfiltered ("trap  "); break;
284         case 3: printf_unfiltered ("empty "); break;
285         }
286       for (i = 9; i >= 0; i--)
287         printf_unfiltered ("%02x", ep->regs[st_regno][i]);
288       
289       printf_unfiltered ("  ");
290
291       /*
292        * Handle weird cases better than floatformat_to_double () and
293        * printf ().
294        */
295       usregs = (unsigned short *) ep->regs[st_regno];
296       sign = usregs[4] & 0x8000 ? "-" : "";
297       exp = usregs[4] & 0x7fff;
298       normal = usregs[3] & 0x8000;
299       mantissa_or = usregs[0] | usregs[1] | usregs[2] | (usregs[3] & 0x7fff);
300       if (exp == 0)
301         {
302           if (normal)
303             printf_unfiltered ("Pseudo Denormal (0 as a double)");
304           else if (mantissa_or == 0)
305             printf_unfiltered ("%s0", sign);
306           else
307             printf_unfiltered ("Denormal (0 as a double)");
308         }
309       else if (exp == 0x7fff)
310         {
311           if (!normal)
312             printf_unfiltered ("Pseudo ");
313           if (mantissa_or == 0)
314             printf_unfiltered ("%sInf", sign);
315           else
316             printf_unfiltered ("%s NaN",
317                                usregs[3] & 0x4000 ? "Quiet" : "Signaling");
318           if (!normal)
319             printf_unfiltered (" (NaN)");
320         }
321       else if (!normal)
322         printf_unfiltered ("Unnormal (NaN)");
323       else
324         {
325 #if 0
326           /* Use this we stop trapping on overflow.  */
327           floatformat_to_double(&floatformat_i387_ext,
328                                 (char *) ep->regs[st_regno], &val);
329 #else
330           i387_to_double((char *) ep->regs[st_regno], (char *) &val);
331 #endif
332           printf_unfiltered ("%g", val);
333         }
334       printf_unfiltered ("\n");
335     }
336 }
337
338 void
339 i386_float_info ()
340 {
341   struct user u; /* just for address computations */
342   int i;
343   /* fpstate defined in <sys/user.h> */
344   struct fpstate *fpstatep;
345   char buf[sizeof (struct fpstate) + 2 * sizeof (int)];
346   unsigned int uaddr;
347   char fpvalid;
348   unsigned int rounded_addr;
349   unsigned int rounded_size;
350   /*extern int corechan;*/
351   int skip;
352   extern int inferior_pid;
353   
354   uaddr = (char *)&U_FPSTATE(u) - (char *)&u;
355   if (inferior_pid != 0 && core_bfd == NULL) 
356     {
357       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
358       ptrace(PT_GETFPREGS, pid, &buf[0], sizeof(struct fpreg));
359       fpstatep = (struct fpstate *)&buf[0];
360     } 
361   else 
362     fpstatep = &pcb_savefpu;
363
364   print_387_status (fpstatep->sv_ex_sw, (struct env387 *)fpstatep);
365 }
366 #endif /* FLOAT_INFO */
367
368 int
369 kernel_u_size ()
370 {
371   return (sizeof (struct user));
372 }
373
374 #ifdef  SETUP_ARBITRARY_FRAME
375 #include "frame.h"
376 struct frame_info *
377 setup_arbitrary_frame (argc, argv)
378         int argc;
379         CORE_ADDR *argv;
380 {
381     if (argc != 2)
382         error ("i386 frame specifications require two arguments: sp and pc");
383
384     return create_new_frame (argv[0], argv[1]);
385 }
386 #endif  /* SETUP_ARBITRARY_FRAME */
387
388 #ifdef HAVE_GREGSET_T
389 void
390 supply_gregset (gp)
391   gregset_t *gp;
392 {
393   int regno = 0;
394
395   /* These must be ordered the same as REGISTER_NAMES in
396      config/i386/tm-i386.h. */
397   supply_register (regno++, (char *)&gp->r_eax);
398   supply_register (regno++, (char *)&gp->r_ecx);
399   supply_register (regno++, (char *)&gp->r_edx);
400   supply_register (regno++, (char *)&gp->r_ebx);
401   supply_register (regno++, (char *)&gp->r_esp);
402   supply_register (regno++, (char *)&gp->r_ebp);
403   supply_register (regno++, (char *)&gp->r_esi);
404   supply_register (regno++, (char *)&gp->r_edi);
405   supply_register (regno++, (char *)&gp->r_eip);
406   supply_register (regno++, (char *)&gp->r_eflags);
407   supply_register (regno++, (char *)&gp->r_cs);
408   supply_register (regno++, (char *)&gp->r_ss);
409   supply_register (regno++, (char *)&gp->r_ds);
410   supply_register (regno++, (char *)&gp->r_es);
411   supply_register (regno++, (char *)&gp->r_fs);
412   supply_register (regno++, (char *)&gp->r_gs);
413 }
414 #endif  /* HAVE_GREGSET_T */
415
416 #ifdef HAVE_FPREGSET_T
417 void
418 supply_fpregset (fp)
419   fpregset_t *fp;
420 {
421   memcpy (&pcb_savefpu, fp, sizeof pcb_savefpu);
422 }
423 #endif  /* HAVE_FPREGSET_T */
424 \f
425 /* Register that we are able to handle aout (trad-core) file formats.  */
426
427 static struct core_fns aout_core_fns =
428 {
429   bfd_target_unknown_flavour,
430   fetch_core_registers,
431   NULL
432 };
433
434 void
435 _initialize_core_aout ()
436 {
437   add_core_fns (&aout_core_fns);
438 }
439
440 #ifdef PT_GETDBREGS
441
442 /*
443  * 0: no trace output
444  * 1: trace watchpoint requests
445  * 2: trace `watchpoint hit?' tests, too
446  */
447 #define WATCHPOINT_DEBUG 0
448
449 #include "breakpoint.h"
450
451 int
452 can_watch(type, cnt, ot)
453      int type, cnt, ot;
454 {
455   int rv;
456   static int cnt_watch, cnt_awatch;
457
458   switch (type)
459     {
460     case bp_hardware_watchpoint:
461       cnt_watch = cnt;
462       break;
463       
464     case bp_access_watchpoint:
465       cnt_awatch = cnt;
466       break;
467       
468     default:
469       rv = 0;
470       goto overandout;
471     }
472
473   rv = cnt_watch + cnt_awatch <= 4? 1: -1;
474
475  overandout:
476 #if WATCHPOINT_DEBUG
477   printf_filtered("can_watch(%d, %d, %d) = %d (counts: w: %d, rw: %d)\n",
478                   type, cnt, ot, rv, cnt_watch, cnt_awatch);
479 #endif
480
481   return rv;
482 }
483
484 int
485 stopped_by_watchpoint()
486 {
487   struct dbreg dbr;
488   extern int inferior_pid;
489
490   if (current_target.to_shortname == 0 ||
491       ! (strcmp(current_target.to_shortname, "child") == 0 ||
492          strcmp(current_target.to_shortname, "freebsd-uthreads") == 0))
493     return 0;
494   
495   if (inferior_pid != 0 && core_bfd == NULL) 
496     {
497       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
498   
499       if (ptrace(PT_GETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
500         {
501           perror("ptrace(PT_GETDBREGS) failed");
502           return 0;
503         }
504 #if WATCHPOINT_DEBUG > 1
505       printf_filtered("stopped_by_watchpoint(): DR6 = %#x\n", dbr.dr6);
506 #endif
507       /*
508        * If a hardware watchpoint was hit, one of the lower 4 bits in
509        * DR6 is set (the actual bit indicates which of DR0...DR3 triggered
510        * the trap).
511        */
512       return dbr.dr6 & 0x0f;
513     } 
514   else
515     {
516       warning("Can't set a watchpoint on a core file.");
517       return 0;
518     }
519 }
520
521 int
522 insert_watchpoint(addr, len, type)
523      int addr, len, type;
524 {
525   struct dbreg dbr;
526   extern int inferior_pid;
527   
528   if (current_target.to_shortname == 0 ||
529       ! (strcmp(current_target.to_shortname, "child") == 0 ||
530          strcmp(current_target.to_shortname, "freebsd-uthreads") == 0))
531     return 0;
532   
533   if (inferior_pid != 0 && core_bfd == NULL) 
534     {
535       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
536       int i, mask;
537       unsigned int sbits;
538
539       if (ptrace(PT_GETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
540         {
541           perror("ptrace(PT_GETDBREGS) failed");
542           return 0;
543         }
544
545       for (i = 0, mask = 0x03; i < 4; i++, mask <<= 2)
546         if ((dbr.dr7 & mask) == 0)
547           break;
548       if (i >= 4) {
549         warning("no more hardware watchpoints available");
550         return -1;
551       }
552
553       /* paranoia */
554       if (len > 4)
555         {
556           warning("watchpoint length %d unsupported, using lenght = 4",
557                   len);
558           len = 4;
559         }
560       else if (len == 3)
561         {
562           warning("weird watchpoint length 3, using 2");
563           len = 2;
564         }
565       else if (len == 0)
566         {
567           warning("weird watchpoint length 0, using 1");
568           len = 1;
569         }
570
571       switch (len)
572         {
573         case 1: sbits = 0; break;
574         case 2: sbits = 4; break;
575         case 4: sbits = 0x0c; break;
576         }
577       
578       /*
579        *  The `type' value is 0 for `watch on write', 1 for `watch on
580        * read', 2 for `watch on both'.  The i386 debug register
581        * breakpoint types are 0 for `execute' (not used in GDB), 1 for
582        * `write', and 4 for `read/write'.  Plain `read' trapping is
583        * not supported on i386, value 3 is illegal.
584        */
585       switch (type)
586         {
587         default:
588           warning("weird watchpoint type %d, using a write watchpoint");
589           /* FALLTHROUGH */
590         case 0:
591           sbits |= 1;
592           break;
593
594         case 2:
595           sbits |= 3;
596           break;
597         }
598       sbits <<= 4 * i + 16;
599       sbits |= 1 << 2 * i;
600
601       dbr.dr7 |= sbits;
602       *(&dbr.dr0 + i) = (unsigned int)addr;
603
604 #if WATCHPOINT_DEBUG
605       printf_filtered("insert_watchpoint(), inserting DR7 = %#x, DR%d = %#x\n",
606                       dbr.dr7, i, addr);
607 #endif
608       if (ptrace(PT_SETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
609         {
610           perror("ptrace(PT_SETDBREGS) failed");
611           return 0;
612         }
613     }
614   else
615     {
616       warning("Can't set a watchpoint on a core file.");
617       return 0;
618     }
619 }
620
621 int
622 remove_watchpoint(addr, len, type)
623      int addr, len, type;
624 {
625   struct dbreg dbr;
626   extern int inferior_pid;
627   
628   if (current_target.to_shortname == 0 ||
629       ! (strcmp(current_target.to_shortname, "child") == 0 ||
630          strcmp(current_target.to_shortname, "freebsd-uthreads") == 0))
631     return 0;
632
633   if (inferior_pid != 0 && core_bfd == NULL) 
634     {
635       int pid = inferior_pid & ((1 << 17) - 1); /* XXX extract pid from tid */
636       int i;
637       unsigned int sbits, *dbregp;
638   
639       if (ptrace(PT_GETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
640         {
641           perror("ptrace(PT_GETDBREGS) failed");
642           return 0;
643         }
644
645       for (i = 0, dbregp = &dbr.dr0; i < 4; i++, dbregp++)
646         if (*dbregp == (unsigned int)addr)
647           break;
648       if (i >= 4)
649         {
650           warning("watchpoint for address %#x not found", addr);
651           return -1;
652         }
653
654       *dbregp = 0;
655       sbits = 0xf << (4 * i + 16);
656       sbits |= 3 << 2 * i;
657       dbr.dr7 &= ~sbits;
658
659 #if WATCHPOINT_DEBUG
660       printf_filtered("remove_watchpoint(): removing watchpoint for %#x, DR7 = %#x\n",
661                       addr, dbr.dr7);
662 #endif
663       if (ptrace(PT_SETDBREGS, pid, (caddr_t)&dbr, 0) == -1)
664         {
665           perror("ptrace(PT_SETDBREGS) failed");
666           return 0;
667         }
668     }
669   else
670     {
671       warning("Can't set a watchpoint on a core file.");
672       return 0;
673     }
674 }
675
676 #endif /* PT_GETDBREGS */