gdb/arm-linux-nat.c

   1 /* GNU/Linux on ARM native support.
   2    Copyright 1999, 2000 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
  26 #include <sys/user.h>
  27 #include <sys/ptrace.h>
  28 #include <sys/utsname.h>
  29
  30 extern int arm_apcs_32;
  31
  32 #define         typeNone                0x00
  33 #define         typeSingle              0x01
  34 #define         typeDouble              0x02
  35 #define         typeExtended            0x03
  36 #define         FPWORDS                 28
  37 #define         CPSR_REGNUM             16
  38
  39 typedef union tagFPREG
  40   {
  41     unsigned int fSingle;
  42     unsigned int fDouble[2];
  43     unsigned int fExtended[3];
  44   }
  45 FPREG;
  46
  47 typedef struct tagFPA11
  48   {
  49     FPREG fpreg[8];             /* 8 floating point registers */
  50     unsigned int fpsr;          /* floating point status register */
  51     unsigned int fpcr;          /* floating point control register */
  52     unsigned char fType[8];     /* type of floating point value held in
  53                                    floating point registers.  */
  54     int initflag;               /* NWFPE initialization flag.  */
  55   }
  56 FPA11;
  57
  58 /* The following variables are used to determine the version of the
  59    underlying Linux operating system.  Examples:
  60
  61    Linux 2.0.35                 Linux 2.2.12
  62    os_version = 0x00020023      os_version = 0x0002020c
  63    os_major = 2                 os_major = 2
  64    os_minor = 0                 os_minor = 2
  65    os_release = 35              os_release = 12
  66
  67    Note: os_version = (os_major << 16) | (os_minor << 8) | os_release
  68
  69    These are initialized using get_linux_version() from
  70    _initialize_arm_linux_nat().  */
  71
  72 static unsigned int os_version, os_major, os_minor, os_release;
  73
  74 static void
  75 fetch_nwfpe_single (unsigned int fn, FPA11 * fpa11)
  76 {
  77   unsigned int mem[3];
  78
  79   mem[0] = fpa11->fpreg[fn].fSingle;
  80   mem[1] = 0;
  81   mem[2] = 0;
  82   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
  83 }
  84
  85 static void
  86 fetch_nwfpe_double (unsigned int fn, FPA11 * fpa11)
  87 {
  88   unsigned int mem[3];
  89
  90   mem[0] = fpa11->fpreg[fn].fDouble[1];
  91   mem[1] = fpa11->fpreg[fn].fDouble[0];
  92   mem[2] = 0;
  93   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
  94 }
  95
  96 static void
  97 fetch_nwfpe_none (unsigned int fn)
  98 {
  99   unsigned int mem[3] =
 100   {0, 0, 0};
 101
 102   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
 103 }
 104
 105 static void
 106 fetch_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
 107 {
 108   unsigned int mem[3];
 109
 110   mem[0] = fpa11->fpreg[fn].fExtended[0];       /* sign & exponent */
 111   mem[1] = fpa11->fpreg[fn].fExtended[2];       /* ls bits */
 112   mem[2] = fpa11->fpreg[fn].fExtended[1];       /* ms bits */
 113   supply_register (F0_REGNUM + fn, (char *) &mem[0]);
 114 }
 115
 116 static void
 117 store_nwfpe_single (unsigned int fn, FPA11 * fpa11)
 118 {
 119   unsigned int mem[3];
 120
 121   read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
 122   fpa11->fpreg[fn].fSingle = mem[0];
 123   fpa11->fType[fn] = typeSingle;
 124 }
 125
 126 static void
 127 store_nwfpe_double (unsigned int fn, FPA11 * fpa11)
 128 {
 129   unsigned int mem[3];
 130
 131   read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
 132   fpa11->fpreg[fn].fDouble[1] = mem[0];
 133   fpa11->fpreg[fn].fDouble[0] = mem[1];
 134   fpa11->fType[fn] = typeDouble;
 135 }
 136
 137 void
 138 store_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
 139 {
 140   unsigned int mem[3];
 141
 142   read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
 143   fpa11->fpreg[fn].fExtended[0] = mem[0];       /* sign & exponent */
 144   fpa11->fpreg[fn].fExtended[2] = mem[1];       /* ls bits */
 145   fpa11->fpreg[fn].fExtended[1] = mem[2];       /* ms bits */
 146   fpa11->fType[fn] = typeDouble;
 147 }
 148
 149 /* Get the whole floating point state of the process and store the
 150    floating point stack into registers[].  */
 151
 152 static void
 153 fetch_fpregs (void)
 154 {
 155   int ret, regno;
 156   FPA11 fp;
 157
 158   /* Read the floating point state.  */
 159   ret = ptrace (PT_GETFPREGS, inferior_pid, 0, &fp);
 160   if (ret < 0)
 161     {
 162       warning ("Unable to fetch the floating point state.");
 163       return;
 164     }
 165
 166   /* Fetch fpsr.  */
 167   supply_register (FPS_REGNUM, (char *) &fp.fpsr);
 168
 169   /* Fetch the floating point registers.  */
 170   for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
 171     {
 172       int fn = regno - F0_REGNUM;
 173
 174       switch (fp.fType[fn])
 175         {
 176         case typeSingle:
 177           fetch_nwfpe_single (fn, &fp);
 178           break;
 179
 180         case typeDouble:
 181           fetch_nwfpe_double (fn, &fp);
 182           break;
 183
 184         case typeExtended:
 185           fetch_nwfpe_extended (fn, &fp);
 186           break;
 187
 188         default:
 189           fetch_nwfpe_none (fn);
 190         }
 191     }
 192 }
 193
 194 /* Save the whole floating point state of the process using
 195    the contents from registers[].  */
 196
 197 static void
 198 store_fpregs (void)
 199 {
 200   int ret, regno;
 201   FPA11 fp;
 202
 203   /* Store fpsr.  */
 204   if (register_valid[FPS_REGNUM])
 205     read_register_gen (FPS_REGNUM, (char *) &fp.fpsr);
 206
 207   /* Store the floating point registers.  */
 208   for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
 209     {
 210       if (register_valid[regno])
 211         {
 212           unsigned int fn = regno - F0_REGNUM;
 213           switch (fp.fType[fn])
 214             {
 215             case typeSingle:
 216               store_nwfpe_single (fn, &fp);
 217               break;
 218
 219             case typeDouble:
 220               store_nwfpe_double (fn, &fp);
 221               break;
 222
 223             case typeExtended:
 224               store_nwfpe_extended (fn, &fp);
 225               break;
 226             }
 227         }
 228     }
 229
 230   ret = ptrace (PTRACE_SETFPREGS, inferior_pid, 0, &fp);
 231   if (ret < 0)
 232     {
 233       warning ("Unable to store floating point state.");
 234       return;
 235     }
 236 }
 237
 238 /* Fetch all general registers of the process and store into
 239    registers[].  */
 240
 241 static void
 242 fetch_regs (void)
 243 {
 244   int ret, regno;
 245   struct pt_regs regs;
 246
 247   ret = ptrace (PTRACE_GETREGS, inferior_pid, 0, &regs);
 248   if (ret < 0)
 249     {
 250       warning ("Unable to fetch general registers.");
 251       return;
 252     }
 253
 254   for (regno = A1_REGNUM; regno < PC_REGNUM; regno++)
 255     supply_register (regno, (char *) &regs.uregs[regno]);
 256
 257   if (arm_apcs_32)
 258     supply_register (PS_REGNUM, (char *) &regs.uregs[CPSR_REGNUM]);
 259   else
 260     supply_register (PS_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
 261
 262   regs.uregs[PC_REGNUM] = ADDR_BITS_REMOVE (regs.uregs[PC_REGNUM]);
 263   supply_register (PC_REGNUM, (char *) &regs.uregs[PC_REGNUM]);
 264 }
 265
 266 /* Store all general registers of the process from the values in
 267    registers[].  */
 268
 269 static void
 270 store_regs (void)
 271 {
 272   int ret, regno;
 273   struct pt_regs regs;
 274
 275   ret = ptrace (PTRACE_GETREGS, inferior_pid, 0, &regs);
 276   if (ret < 0)
 277     {
 278       warning ("Unable to fetch general registers.");
 279       return;
 280     }
 281
 282   for (regno = A1_REGNUM; regno <= PC_REGNUM; regno++)
 283     {
 284       if (register_valid[regno])
 285         read_register_gen (regno, (char *) &regs.uregs[regno]);
 286     }
 287
 288   ret = ptrace (PTRACE_SETREGS, inferior_pid, 0, &regs);
 289
 290   if (ret < 0)
 291     {
 292       warning ("Unable to store general registers.");
 293       return;
 294     }
 295 }
 296
 297 /* Fetch registers from the child process.  Fetch all registers if
 298    regno == -1, otherwise fetch all general registers or all floating
 299    point registers depending upon the value of regno.  */
 300
 301 void
 302 fetch_inferior_registers (int regno)
 303 {
 304   if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
 305     fetch_regs ();
 306
 307   if (((regno >= F0_REGNUM) && (regno <= FPS_REGNUM)) || (regno == -1))
 308     fetch_fpregs ();
 309 }
 310
 311 /* Store registers back into the inferior.  Store all registers if
 312    regno == -1, otherwise store all general registers or all floating
 313    point registers depending upon the value of regno.  */
 314
 315 void
 316 store_inferior_registers (int regno)
 317 {
 318   if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
 319     store_regs ();
 320
 321   if (((regno >= F0_REGNUM) && (regno <= FPS_REGNUM)) || (regno == -1))
 322     store_fpregs ();
 323 }
 324
 325 int
 326 arm_linux_register_u_addr (int blockend, int regnum)
 327 {
 328   return blockend + REGISTER_BYTE (regnum);
 329 }
 330
 331 int
 332 arm_linux_kernel_u_size (void)
 333 {
 334   return (sizeof (struct user));
 335 }
 336
 337 static unsigned int
 338 get_linux_version (unsigned int *vmajor,
 339                    unsigned int *vminor,
 340                    unsigned int *vrelease)
 341 {
 342   struct utsname info;
 343   char *pmajor, *pminor, *prelease, *tail;
 344
 345   if (-1 == uname (&info))
 346     {
 347       warning ("Unable to determine Linux version.");
 348       return -1;
 349     }
 350
 351   pmajor = strtok (info.release, ".");
 352   pminor = strtok (NULL, ".");
 353   prelease = strtok (NULL, ".");
 354
 355   *vmajor = (unsigned int) strtoul (pmajor, &tail, 0);
 356   *vminor = (unsigned int) strtoul (pminor, &tail, 0);
 357   *vrelease = (unsigned int) strtoul (prelease, &tail, 0);
 358
 359   return ((*vmajor << 16) | (*vminor << 8) | *vrelease);
 360 }
 361
 362 void
 363 _initialize_arm_linux_nat (void)
 364 {
 365   os_version = get_linux_version (&os_major, &os_minor, &os_release);
 366 }