* arm-linux-nat.c: Include <asm/ptrace.h> explicitly.
[platform/upstream/binutils.git] / gdb / arm-linux-nat.c
1 /* GNU/Linux on ARM native support.
2    Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
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,
19    Boston, MA 02111-1307, USA.  */
20
21 #include "defs.h"
22 #include "inferior.h"
23 #include "gdbcore.h"
24 #include "gdb_string.h"
25 #include "regcache.h"
26
27 #include <sys/user.h>
28 #include <sys/ptrace.h>
29 #include <sys/utsname.h>
30 #include <sys/procfs.h>
31
32 #include <asm/ptrace.h>
33
34 /* Prototypes for supply_gregset etc. */
35 #include "gregset.h"
36
37 extern int arm_apcs_32;
38
39 #define         typeNone                0x00
40 #define         typeSingle              0x01
41 #define         typeDouble              0x02
42 #define         typeExtended            0x03
43 #define         FPWORDS                 28
44 #define         CPSR_REGNUM             16
45
46 typedef union tagFPREG
47   {
48     unsigned int fSingle;
49     unsigned int fDouble[2];
50     unsigned int fExtended[3];
51   }
52 FPREG;
53
54 typedef struct tagFPA11
55   {
56     FPREG fpreg[8];             /* 8 floating point registers */
57     unsigned int fpsr;          /* floating point status register */
58     unsigned int fpcr;          /* floating point control register */
59     unsigned char fType[8];     /* type of floating point value held in
60                                    floating point registers.  */
61     int initflag;               /* NWFPE initialization flag.  */
62   }
63 FPA11;
64
65 /* The following variables are used to determine the version of the
66    underlying Linux operating system.  Examples:
67
68    Linux 2.0.35                 Linux 2.2.12
69    os_version = 0x00020023      os_version = 0x0002020c
70    os_major = 2                 os_major = 2
71    os_minor = 0                 os_minor = 2
72    os_release = 35              os_release = 12
73
74    Note: os_version = (os_major << 16) | (os_minor << 8) | os_release
75
76    These are initialized using get_linux_version() from
77    _initialize_arm_linux_nat().  */
78
79 static unsigned int os_version, os_major, os_minor, os_release;
80
81 /* On Linux, threads are implemented as pseudo-processes, in which
82    case we may be tracing more than one process at a time.  In that
83    case, inferior_ptid will contain the main process ID and the
84    individual thread (process) ID.  get_thread_id () is used to
85    get the thread id if it's available, and the process id otherwise. */
86
87 int
88 get_thread_id (ptid_t ptid)
89 {
90   int tid = TIDGET (ptid);
91   if (0 == tid)
92     tid = PIDGET (ptid);
93   return tid;
94 }
95 #define GET_THREAD_ID(PTID)     get_thread_id ((PTID));
96
97 static void
98 fetch_nwfpe_single (unsigned int fn, FPA11 * fpa11)
99 {
100   unsigned int mem[3];
101
102   mem[0] = fpa11->fpreg[fn].fSingle;
103   mem[1] = 0;
104   mem[2] = 0;
105   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
106 }
107
108 static void
109 fetch_nwfpe_double (unsigned int fn, FPA11 * fpa11)
110 {
111   unsigned int mem[3];
112
113   mem[0] = fpa11->fpreg[fn].fDouble[1];
114   mem[1] = fpa11->fpreg[fn].fDouble[0];
115   mem[2] = 0;
116   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
117 }
118
119 static void
120 fetch_nwfpe_none (unsigned int fn)
121 {
122   unsigned int mem[3] =
123   {0, 0, 0};
124
125   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
126 }
127
128 static void
129 fetch_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
130 {
131   unsigned int mem[3];
132
133   mem[0] = fpa11->fpreg[fn].fExtended[0];       /* sign & exponent */
134   mem[1] = fpa11->fpreg[fn].fExtended[2];       /* ls bits */
135   mem[2] = fpa11->fpreg[fn].fExtended[1];       /* ms bits */
136   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
137 }
138
139 static void
140 fetch_nwfpe_register (int regno, FPA11 * fpa11)
141 {
142    int fn = regno - F0_REGNUM;
143
144    switch (fpa11->fType[fn])
145      {
146      case typeSingle:
147        fetch_nwfpe_single (fn, fpa11);
148        break;
149
150      case typeDouble:
151        fetch_nwfpe_double (fn, fpa11);
152        break;
153
154      case typeExtended:
155        fetch_nwfpe_extended (fn, fpa11);
156        break;
157
158      default:
159        fetch_nwfpe_none (fn);
160      }
161 }
162
163 static void
164 store_nwfpe_single (unsigned int fn, FPA11 * fpa11)
165 {
166   unsigned int mem[3];
167
168   read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
169   fpa11->fpreg[fn].fSingle = mem[0];
170   fpa11->fType[fn] = typeSingle;
171 }
172
173 static void
174 store_nwfpe_double (unsigned int fn, FPA11 * fpa11)
175 {
176   unsigned int mem[3];
177
178   read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
179   fpa11->fpreg[fn].fDouble[1] = mem[0];
180   fpa11->fpreg[fn].fDouble[0] = mem[1];
181   fpa11->fType[fn] = typeDouble;
182 }
183
184 void
185 store_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
186 {
187   unsigned int mem[3];
188
189   read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
190   fpa11->fpreg[fn].fExtended[0] = mem[0];       /* sign & exponent */
191   fpa11->fpreg[fn].fExtended[2] = mem[1];       /* ls bits */
192   fpa11->fpreg[fn].fExtended[1] = mem[2];       /* ms bits */
193   fpa11->fType[fn] = typeDouble;
194 }
195
196 void
197 store_nwfpe_register (int regno, FPA11 * fpa11)
198 {
199   if (register_valid[regno])
200     {
201        unsigned int fn = regno - F0_REGNUM;
202        switch (fpa11->fType[fn])
203          {
204          case typeSingle:
205            store_nwfpe_single (fn, fpa11);
206            break;
207
208          case typeDouble:
209            store_nwfpe_double (fn, fpa11);
210            break;
211
212          case typeExtended:
213            store_nwfpe_extended (fn, fpa11);
214            break;
215          }
216     }
217 }
218
219
220 /* Get the value of a particular register from the floating point
221    state of the process and store it into registers[].  */
222
223 static void
224 fetch_fpregister (int regno)
225 {
226   int ret, tid;
227   FPA11 fp;
228   
229   /* Get the thread id for the ptrace call.  */
230   tid = GET_THREAD_ID (inferior_ptid);
231
232   /* Read the floating point state.  */
233   ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
234   if (ret < 0)
235     {
236       warning ("Unable to fetch floating point register.");
237       return;
238     }
239
240   /* Fetch fpsr.  */
241   if (FPS_REGNUM == regno)
242     supply_register (FPS_REGNUM, (char *) &fp.fpsr);
243
244   /* Fetch the floating point register.  */
245   if (regno >= F0_REGNUM && regno <= F7_REGNUM)
246     {
247       int fn = regno - F0_REGNUM;
248
249       switch (fp.fType[fn])
250         {
251         case typeSingle:
252           fetch_nwfpe_single (fn, &fp);
253           break;
254
255         case typeDouble:
256             fetch_nwfpe_double (fn, &fp);
257           break;
258
259         case typeExtended:
260             fetch_nwfpe_extended (fn, &fp);
261           break;
262
263         default:
264             fetch_nwfpe_none (fn);
265         }
266     }
267 }
268
269 /* Get the whole floating point state of the process and store it
270    into registers[].  */
271
272 static void
273 fetch_fpregs (void)
274 {
275   int ret, regno, tid;
276   FPA11 fp;
277
278   /* Get the thread id for the ptrace call.  */
279   tid = GET_THREAD_ID (inferior_ptid);
280   
281   /* Read the floating point state.  */
282   ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
283   if (ret < 0)
284     {
285       warning ("Unable to fetch the floating point registers.");
286       return;
287     }
288
289   /* Fetch fpsr.  */
290   supply_register (FPS_REGNUM, (char *) &fp.fpsr);
291
292   /* Fetch the floating point registers.  */
293   for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
294     {
295       int fn = regno - F0_REGNUM;
296
297       switch (fp.fType[fn])
298         {
299         case typeSingle:
300           fetch_nwfpe_single (fn, &fp);
301           break;
302
303         case typeDouble:
304           fetch_nwfpe_double (fn, &fp);
305           break;
306
307         case typeExtended:
308           fetch_nwfpe_extended (fn, &fp);
309           break;
310
311         default:
312           fetch_nwfpe_none (fn);
313         }
314     }
315 }
316
317 /* Save a particular register into the floating point state of the
318    process using the contents from registers[].  */
319
320 static void
321 store_fpregister (int regno)
322 {
323   int ret, tid;
324   FPA11 fp;
325
326   /* Get the thread id for the ptrace call.  */
327   tid = GET_THREAD_ID (inferior_ptid);
328   
329   /* Read the floating point state.  */
330   ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
331   if (ret < 0)
332     {
333       warning ("Unable to fetch the floating point registers.");
334       return;
335     }
336
337   /* Store fpsr.  */
338   if (FPS_REGNUM == regno && register_valid[FPS_REGNUM])
339     read_register_gen (FPS_REGNUM, (char *) &fp.fpsr);
340
341   /* Store the floating point register.  */
342   if (regno >= F0_REGNUM && regno <= F7_REGNUM)
343     {
344       store_nwfpe_register (regno, &fp);
345     }
346
347   ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
348   if (ret < 0)
349     {
350       warning ("Unable to store floating point register.");
351       return;
352     }
353 }
354
355 /* Save the whole floating point state of the process using
356    the contents from registers[].  */
357
358 static void
359 store_fpregs (void)
360 {
361   int ret, regno, tid;
362   FPA11 fp;
363
364   /* Get the thread id for the ptrace call.  */
365   tid = GET_THREAD_ID (inferior_ptid);
366   
367   /* Read the floating point state.  */
368   ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
369   if (ret < 0)
370     {
371       warning ("Unable to fetch the floating point registers.");
372       return;
373     }
374
375   /* Store fpsr.  */
376   if (register_valid[FPS_REGNUM])
377     read_register_gen (FPS_REGNUM, (char *) &fp.fpsr);
378
379   /* Store the floating point registers.  */
380   for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
381     {
382       fetch_nwfpe_register (regno, &fp);
383     }
384
385   ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
386   if (ret < 0)
387     {
388       warning ("Unable to store floating point registers.");
389       return;
390     }
391 }
392
393 /* Fetch a general register of the process and store into
394    registers[].  */
395
396 static void
397 fetch_register (int regno)
398 {
399   int ret, tid;
400   struct pt_regs regs;
401
402   /* Get the thread id for the ptrace call.  */
403   tid = GET_THREAD_ID (inferior_ptid);
404   
405   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
406   if (ret < 0)
407     {
408       warning ("Unable to fetch general register.");
409       return;
410     }
411
412   if (regno >= A1_REGNUM && regno < PC_REGNUM)
413     supply_register (regno, (char *) &regs.uregs[regno]);
414
415   if (PS_REGNUM == regno)
416     {
417       if (arm_apcs_32)
418         supply_register (PS_REGNUM, (char *) &regs.uregs[CPSR_REGNUM]);
419       else
420         supply_register (PS_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
421     }
422     
423   if (PC_REGNUM == regno)
424     { 
425       regs.uregs[PC_REGNUM] = ADDR_BITS_REMOVE (regs.uregs[PC_REGNUM]);
426       supply_register (PC_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
427     }
428 }
429
430 /* Fetch all general registers of the process and store into
431    registers[].  */
432
433 static void
434 fetch_regs (void)
435 {
436   int ret, regno, tid;
437   struct pt_regs regs;
438
439   /* Get the thread id for the ptrace call.  */
440   tid = GET_THREAD_ID (inferior_ptid);
441   
442   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
443   if (ret < 0)
444     {
445       warning ("Unable to fetch general registers.");
446       return;
447     }
448
449   for (regno = A1_REGNUM; regno < PC_REGNUM; regno++)
450     supply_register (regno, (char *) &regs.uregs[regno]);
451
452   if (arm_apcs_32)
453     supply_register (PS_REGNUM, (char *) &regs.uregs[CPSR_REGNUM]);
454   else
455     supply_register (PS_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
456
457   regs.uregs[PC_REGNUM] = ADDR_BITS_REMOVE (regs.uregs[PC_REGNUM]);
458   supply_register (PC_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
459 }
460
461 /* Store all general registers of the process from the values in
462    registers[].  */
463
464 static void
465 store_register (int regno)
466 {
467   int ret, tid;
468   struct pt_regs regs;
469   
470   if (!register_valid[regno])
471     return;
472
473   /* Get the thread id for the ptrace call.  */
474   tid = GET_THREAD_ID (inferior_ptid);
475   
476   /* Get the general registers from the process.  */
477   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
478   if (ret < 0)
479     {
480       warning ("Unable to fetch general registers.");
481       return;
482     }
483
484   if (regno >= A1_REGNUM && regno <= PC_REGNUM)
485     read_register_gen (regno, (char *) &regs.uregs[regno]);
486
487   ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
488   if (ret < 0)
489     {
490       warning ("Unable to store general register.");
491       return;
492     }
493 }
494
495 static void
496 store_regs (void)
497 {
498   int ret, regno, tid;
499   struct pt_regs regs;
500
501   /* Get the thread id for the ptrace call.  */
502   tid = GET_THREAD_ID (inferior_ptid);
503   
504   /* Fetch the general registers.  */
505   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
506   if (ret < 0)
507     {
508       warning ("Unable to fetch general registers.");
509       return;
510     }
511
512   for (regno = A1_REGNUM; regno <= PC_REGNUM; regno++)
513     {
514       if (register_valid[regno])
515         read_register_gen (regno, (char *) &regs.uregs[regno]);
516     }
517
518   ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
519
520   if (ret < 0)
521     {
522       warning ("Unable to store general registers.");
523       return;
524     }
525 }
526
527 /* Fetch registers from the child process.  Fetch all registers if
528    regno == -1, otherwise fetch all general registers or all floating
529    point registers depending upon the value of regno.  */
530
531 void
532 fetch_inferior_registers (int regno)
533 {
534   if (-1 == regno)
535     {
536       fetch_regs ();
537       fetch_fpregs ();
538     }
539   else 
540     {
541       if (regno < F0_REGNUM || regno > FPS_REGNUM)
542         fetch_register (regno);
543
544       if (regno >= F0_REGNUM && regno <= FPS_REGNUM)
545         fetch_fpregister (regno);
546     }
547 }
548
549 /* Store registers back into the inferior.  Store all registers if
550    regno == -1, otherwise store all general registers or all floating
551    point registers depending upon the value of regno.  */
552
553 void
554 store_inferior_registers (int regno)
555 {
556   if (-1 == regno)
557     {
558       store_regs ();
559       store_fpregs ();
560     }
561   else
562     {
563       if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
564         store_register (regno);
565
566       if ((regno >= F0_REGNUM) && (regno <= FPS_REGNUM))
567         store_fpregister (regno);
568     }
569 }
570
571 /* Fill register regno (if it is a general-purpose register) in
572    *gregsetp with the appropriate value from GDB's register array.
573    If regno is -1, do this for all registers.  */
574
575 void
576 fill_gregset (gdb_gregset_t *gregsetp, int regno)
577 {
578   if (-1 == regno)
579     {
580       int regnum;
581       for (regnum = A1_REGNUM; regnum <= PC_REGNUM; regnum++) 
582         read_register_gen (regnum, (char *) &(*gregsetp)[regnum]);
583     }
584   else if (regno >= A1_REGNUM && regno <= PC_REGNUM)
585     read_register_gen (regno, (char *) &(*gregsetp)[regno]);
586
587   if (PS_REGNUM == regno || -1 == regno)
588     {
589       if (arm_apcs_32)
590         read_register_gen (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]);
591       else
592         read_register_gen (PC_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]);
593     }
594 }
595
596 /* Fill GDB's register array with the general-purpose register values
597    in *gregsetp.  */
598
599 void
600 supply_gregset (gdb_gregset_t *gregsetp)
601 {
602   int regno, reg_pc;
603
604   for (regno = A1_REGNUM; regno < PC_REGNUM; regno++)
605     supply_register (regno, (char *) &(*gregsetp)[regno]);
606
607   if (arm_apcs_32)
608     supply_register (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]);
609   else
610     supply_register (PS_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]);
611
612   reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[PC_REGNUM]);
613   supply_register (PC_REGNUM, (char *) &reg_pc);
614 }
615
616 /* Fill register regno (if it is a floating-point register) in
617    *fpregsetp with the appropriate value from GDB's register array.
618    If regno is -1, do this for all registers.  */
619
620 void
621 fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
622 {
623   FPA11 *fp = (FPA11 *) fpregsetp;
624   
625   if (-1 == regno)
626     {
627        int regnum;
628        for (regnum = F0_REGNUM; regnum <= F7_REGNUM; regnum++)
629          store_nwfpe_register (regnum, fp);
630     }
631   else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
632     {
633       store_nwfpe_register (regno, fp);
634       return;
635     }
636
637   /* Store fpsr.  */
638   if (FPS_REGNUM == regno || -1 == regno)
639     read_register_gen (FPS_REGNUM, (char *) &fp->fpsr);
640 }
641
642 /* Fill GDB's register array with the floating-point register values
643    in *fpregsetp.  */
644
645 void
646 supply_fpregset (gdb_fpregset_t *fpregsetp)
647 {
648   int regno;
649   FPA11 *fp = (FPA11 *) fpregsetp;
650
651   /* Fetch fpsr.  */
652   supply_register (FPS_REGNUM, (char *) &fp->fpsr);
653
654   /* Fetch the floating point registers.  */
655   for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
656     {
657       fetch_nwfpe_register (regno, fp);
658     }
659 }
660
661 int
662 arm_linux_kernel_u_size (void)
663 {
664   return (sizeof (struct user));
665 }
666
667 static unsigned int
668 get_linux_version (unsigned int *vmajor,
669                    unsigned int *vminor,
670                    unsigned int *vrelease)
671 {
672   struct utsname info;
673   char *pmajor, *pminor, *prelease, *tail;
674
675   if (-1 == uname (&info))
676     {
677       warning ("Unable to determine Linux version.");
678       return -1;
679     }
680
681   pmajor = strtok (info.release, ".");
682   pminor = strtok (NULL, ".");
683   prelease = strtok (NULL, ".");
684
685   *vmajor = (unsigned int) strtoul (pmajor, &tail, 0);
686   *vminor = (unsigned int) strtoul (pminor, &tail, 0);
687   *vrelease = (unsigned int) strtoul (prelease, &tail, 0);
688
689   return ((*vmajor << 16) | (*vminor << 8) | *vrelease);
690 }
691
692 void
693 _initialize_arm_linux_nat (void)
694 {
695   os_version = get_linux_version (&os_major, &os_minor, &os_release);
696 }