gdb/arm-linux-nat.c

   1 /* GNU/Linux on ARM native support.
   2    Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "gdbcore.h"
  25 #include "gdb_string.h"
  26 #include "regcache.h"
  27 #include "target.h"
  28 #include "linux-nat.h"
  29 #include "target-descriptions.h"
  30 #include "xml-support.h"
  31
  32 #include "arm-tdep.h"
  33 #include "arm-linux-tdep.h"
  34
  35 #include <sys/user.h>
  36 #include <sys/ptrace.h>
  37 #include <sys/utsname.h>
  38 #include <sys/procfs.h>
  39
  40 /* Prototypes for supply_gregset etc. */
  41 #include "gregset.h"
  42
  43 /* Defines ps_err_e, struct ps_prochandle.  */
  44 #include "gdb_proc_service.h"
  45
  46 #ifndef PTRACE_GET_THREAD_AREA
  47 #define PTRACE_GET_THREAD_AREA 22
  48 #endif
  49
  50 #ifndef PTRACE_GETWMMXREGS
  51 #define PTRACE_GETWMMXREGS 18
  52 #define PTRACE_SETWMMXREGS 19
  53 #endif
  54
  55 /* A flag for whether the WMMX registers are available.  */
  56 static int arm_linux_has_wmmx_registers;
  57
  58 extern int arm_apcs_32;
  59
  60 /* The following variables are used to determine the version of the
  61    underlying GNU/Linux operating system.  Examples:
  62
  63    GNU/Linux 2.0.35             GNU/Linux 2.2.12
  64    os_version = 0x00020023      os_version = 0x0002020c
  65    os_major = 2                 os_major = 2
  66    os_minor = 0                 os_minor = 2
  67    os_release = 35              os_release = 12
  68
  69    Note: os_version = (os_major << 16) | (os_minor << 8) | os_release
  70
  71    These are initialized using get_linux_version() from
  72    _initialize_arm_linux_nat().  */
  73
  74 static unsigned int os_version, os_major, os_minor, os_release;
  75
  76 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
  77    case we may be tracing more than one process at a time.  In that
  78    case, inferior_ptid will contain the main process ID and the
  79    individual thread (process) ID.  get_thread_id () is used to get
  80    the thread id if it's available, and the process id otherwise.  */
  81
  82 int
  83 get_thread_id (ptid_t ptid)
  84 {
  85   int tid = TIDGET (ptid);
  86   if (0 == tid)
  87     tid = PIDGET (ptid);
  88   return tid;
  89 }
  90 #define GET_THREAD_ID(PTID)     get_thread_id (PTID)
  91
  92 /* Get the value of a particular register from the floating point
  93    state of the process and store it into regcache.  */
  94
  95 static void
  96 fetch_fpregister (struct regcache *regcache, int regno)
  97 {
  98   int ret, tid;
  99   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 100
 101   /* Get the thread id for the ptrace call.  */
 102   tid = GET_THREAD_ID (inferior_ptid);
 103
 104   /* Read the floating point state.  */
 105   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 106   if (ret < 0)
 107     {
 108       warning (_("Unable to fetch floating point register."));
 109       return;
 110     }
 111
 112   /* Fetch fpsr.  */
 113   if (ARM_FPS_REGNUM == regno)
 114     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 115                          fp + NWFPE_FPSR_OFFSET);
 116
 117   /* Fetch the floating point register.  */
 118   if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
 119     supply_nwfpe_register (regcache, regno, fp);
 120 }
 121
 122 /* Get the whole floating point state of the process and store it
 123    into regcache.  */
 124
 125 static void
 126 fetch_fpregs (struct regcache *regcache)
 127 {
 128   int ret, regno, tid;
 129   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 130
 131   /* Get the thread id for the ptrace call.  */
 132   tid = GET_THREAD_ID (inferior_ptid);
 133
 134   /* Read the floating point state.  */
 135   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 136   if (ret < 0)
 137     {
 138       warning (_("Unable to fetch the floating point registers."));
 139       return;
 140     }
 141
 142   /* Fetch fpsr.  */
 143   regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 144                        fp + NWFPE_FPSR_OFFSET);
 145
 146   /* Fetch the floating point registers.  */
 147   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 148     supply_nwfpe_register (regcache, regno, fp);
 149 }
 150
 151 /* Save a particular register into the floating point state of the
 152    process using the contents from regcache.  */
 153
 154 static void
 155 store_fpregister (const struct regcache *regcache, int regno)
 156 {
 157   int ret, tid;
 158   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 159
 160   /* Get the thread id for the ptrace call.  */
 161   tid = GET_THREAD_ID (inferior_ptid);
 162
 163   /* Read the floating point state.  */
 164   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 165   if (ret < 0)
 166     {
 167       warning (_("Unable to fetch the floating point registers."));
 168       return;
 169     }
 170
 171   /* Store fpsr.  */
 172   if (ARM_FPS_REGNUM == regno && regcache_valid_p (regcache, ARM_FPS_REGNUM))
 173     regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
 174
 175   /* Store the floating point register.  */
 176   if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
 177     collect_nwfpe_register (regcache, regno, fp);
 178
 179   ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
 180   if (ret < 0)
 181     {
 182       warning (_("Unable to store floating point register."));
 183       return;
 184     }
 185 }
 186
 187 /* Save the whole floating point state of the process using
 188    the contents from regcache.  */
 189
 190 static void
 191 store_fpregs (const struct regcache *regcache)
 192 {
 193   int ret, regno, tid;
 194   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 195
 196   /* Get the thread id for the ptrace call.  */
 197   tid = GET_THREAD_ID (inferior_ptid);
 198
 199   /* Read the floating point state.  */
 200   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 201   if (ret < 0)
 202     {
 203       warning (_("Unable to fetch the floating point registers."));
 204       return;
 205     }
 206
 207   /* Store fpsr.  */
 208   if (regcache_valid_p (regcache, ARM_FPS_REGNUM))
 209     regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
 210
 211   /* Store the floating point registers.  */
 212   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 213     if (regcache_valid_p (regcache, regno))
 214       collect_nwfpe_register (regcache, regno, fp);
 215
 216   ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
 217   if (ret < 0)
 218     {
 219       warning (_("Unable to store floating point registers."));
 220       return;
 221     }
 222 }
 223
 224 /* Fetch a general register of the process and store into
 225    regcache.  */
 226
 227 static void
 228 fetch_register (struct regcache *regcache, int regno)
 229 {
 230   int ret, tid;
 231   elf_gregset_t regs;
 232
 233   /* Get the thread id for the ptrace call.  */
 234   tid = GET_THREAD_ID (inferior_ptid);
 235
 236   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 237   if (ret < 0)
 238     {
 239       warning (_("Unable to fetch general register."));
 240       return;
 241     }
 242
 243   if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM)
 244     regcache_raw_supply (regcache, regno, (char *) &regs[regno]);
 245
 246   if (ARM_PS_REGNUM == regno)
 247     {
 248       if (arm_apcs_32)
 249         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 250                              (char *) &regs[ARM_CPSR_REGNUM]);
 251       else
 252         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 253                              (char *) &regs[ARM_PC_REGNUM]);
 254     }
 255
 256   if (ARM_PC_REGNUM == regno)
 257     {
 258       regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
 259       regcache_raw_supply (regcache, ARM_PC_REGNUM,
 260                            (char *) &regs[ARM_PC_REGNUM]);
 261     }
 262 }
 263
 264 /* Fetch all general registers of the process and store into
 265    regcache.  */
 266
 267 static void
 268 fetch_regs (struct regcache *regcache)
 269 {
 270   int ret, regno, tid;
 271   elf_gregset_t regs;
 272
 273   /* Get the thread id for the ptrace call.  */
 274   tid = GET_THREAD_ID (inferior_ptid);
 275
 276   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 277   if (ret < 0)
 278     {
 279       warning (_("Unable to fetch general registers."));
 280       return;
 281     }
 282
 283   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 284     regcache_raw_supply (regcache, regno, (char *) &regs[regno]);
 285
 286   if (arm_apcs_32)
 287     regcache_raw_supply (regcache, ARM_PS_REGNUM,
 288                          (char *) &regs[ARM_CPSR_REGNUM]);
 289   else
 290     regcache_raw_supply (regcache, ARM_PS_REGNUM,
 291                          (char *) &regs[ARM_PC_REGNUM]);
 292
 293   regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
 294   regcache_raw_supply (regcache, ARM_PC_REGNUM,
 295                        (char *) &regs[ARM_PC_REGNUM]);
 296 }
 297
 298 /* Store all general registers of the process from the values in
 299    regcache.  */
 300
 301 static void
 302 store_register (const struct regcache *regcache, int regno)
 303 {
 304   int ret, tid;
 305   elf_gregset_t regs;
 306
 307   if (!regcache_valid_p (regcache, regno))
 308     return;
 309
 310   /* Get the thread id for the ptrace call.  */
 311   tid = GET_THREAD_ID (inferior_ptid);
 312
 313   /* Get the general registers from the process.  */
 314   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 315   if (ret < 0)
 316     {
 317       warning (_("Unable to fetch general registers."));
 318       return;
 319     }
 320
 321   if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
 322     regcache_raw_collect (regcache, regno, (char *) &regs[regno]);
 323   else if (arm_apcs_32 && regno == ARM_PS_REGNUM)
 324     regcache_raw_collect (regcache, regno,
 325                          (char *) &regs[ARM_CPSR_REGNUM]);
 326   else if (!arm_apcs_32 && regno == ARM_PS_REGNUM)
 327     regcache_raw_collect (regcache, ARM_PC_REGNUM,
 328                          (char *) &regs[ARM_PC_REGNUM]);
 329
 330   ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
 331   if (ret < 0)
 332     {
 333       warning (_("Unable to store general register."));
 334       return;
 335     }
 336 }
 337
 338 static void
 339 store_regs (const struct regcache *regcache)
 340 {
 341   int ret, regno, tid;
 342   elf_gregset_t regs;
 343
 344   /* Get the thread id for the ptrace call.  */
 345   tid = GET_THREAD_ID (inferior_ptid);
 346
 347   /* Fetch the general registers.  */
 348   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 349   if (ret < 0)
 350     {
 351       warning (_("Unable to fetch general registers."));
 352       return;
 353     }
 354
 355   for (regno = ARM_A1_REGNUM; regno <= ARM_PC_REGNUM; regno++)
 356     {
 357       if (regcache_valid_p (regcache, regno))
 358         regcache_raw_collect (regcache, regno, (char *) &regs[regno]);
 359     }
 360
 361   if (arm_apcs_32 && regcache_valid_p (regcache, ARM_PS_REGNUM))
 362     regcache_raw_collect (regcache, ARM_PS_REGNUM,
 363                          (char *) &regs[ARM_CPSR_REGNUM]);
 364
 365   ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
 366
 367   if (ret < 0)
 368     {
 369       warning (_("Unable to store general registers."));
 370       return;
 371     }
 372 }
 373
 374 /* Fetch all WMMX registers of the process and store into
 375    regcache.  */
 376
 377 #define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
 378
 379 static void
 380 fetch_wmmx_regs (struct regcache *regcache)
 381 {
 382   char regbuf[IWMMXT_REGS_SIZE];
 383   int ret, regno, tid;
 384
 385   /* Get the thread id for the ptrace call.  */
 386   tid = GET_THREAD_ID (inferior_ptid);
 387
 388   ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
 389   if (ret < 0)
 390     {
 391       warning (_("Unable to fetch WMMX registers."));
 392       return;
 393     }
 394
 395   for (regno = 0; regno < 16; regno++)
 396     regcache_raw_supply (regcache, regno + ARM_WR0_REGNUM,
 397                          &regbuf[regno * 8]);
 398
 399   for (regno = 0; regno < 2; regno++)
 400     regcache_raw_supply (regcache, regno + ARM_WCSSF_REGNUM,
 401                          &regbuf[16 * 8 + regno * 4]);
 402
 403   for (regno = 0; regno < 4; regno++)
 404     regcache_raw_supply (regcache, regno + ARM_WCGR0_REGNUM,
 405                          &regbuf[16 * 8 + 2 * 4 + regno * 4]);
 406 }
 407
 408 static void
 409 store_wmmx_regs (const struct regcache *regcache)
 410 {
 411   char regbuf[IWMMXT_REGS_SIZE];
 412   int ret, regno, tid;
 413
 414   /* Get the thread id for the ptrace call.  */
 415   tid = GET_THREAD_ID (inferior_ptid);
 416
 417   ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
 418   if (ret < 0)
 419     {
 420       warning (_("Unable to fetch WMMX registers."));
 421       return;
 422     }
 423
 424   for (regno = 0; regno < 16; regno++)
 425     if (regcache_valid_p (regcache, regno + ARM_WR0_REGNUM))
 426       regcache_raw_collect (regcache, regno + ARM_WR0_REGNUM,
 427                             &regbuf[regno * 8]);
 428
 429   for (regno = 0; regno < 2; regno++)
 430     if (regcache_valid_p (regcache, regno + ARM_WCSSF_REGNUM))
 431       regcache_raw_collect (regcache, regno + ARM_WCSSF_REGNUM,
 432                             &regbuf[16 * 8 + regno * 4]);
 433
 434   for (regno = 0; regno < 4; regno++)
 435     if (regcache_valid_p (regcache, regno + ARM_WCGR0_REGNUM))
 436       regcache_raw_collect (regcache, regno + ARM_WCGR0_REGNUM,
 437                             &regbuf[16 * 8 + 2 * 4 + regno * 4]);
 438
 439   ret = ptrace (PTRACE_SETWMMXREGS, tid, 0, regbuf);
 440
 441   if (ret < 0)
 442     {
 443       warning (_("Unable to store WMMX registers."));
 444       return;
 445     }
 446 }
 447
 448 /* Fetch registers from the child process.  Fetch all registers if
 449    regno == -1, otherwise fetch all general registers or all floating
 450    point registers depending upon the value of regno.  */
 451
 452 static void
 453 arm_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
 454 {
 455   if (-1 == regno)
 456     {
 457       fetch_regs (regcache);
 458       fetch_fpregs (regcache);
 459       if (arm_linux_has_wmmx_registers)
 460         fetch_wmmx_regs (regcache);
 461     }
 462   else
 463     {
 464       if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
 465         fetch_register (regcache, regno);
 466       else if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
 467         fetch_fpregister (regcache, regno);
 468       else if (arm_linux_has_wmmx_registers
 469                && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
 470         fetch_wmmx_regs (regcache);
 471     }
 472 }
 473
 474 /* Store registers back into the inferior.  Store all registers if
 475    regno == -1, otherwise store all general registers or all floating
 476    point registers depending upon the value of regno.  */
 477
 478 static void
 479 arm_linux_store_inferior_registers (struct regcache *regcache, int regno)
 480 {
 481   if (-1 == regno)
 482     {
 483       store_regs (regcache);
 484       store_fpregs (regcache);
 485       if (arm_linux_has_wmmx_registers)
 486         store_wmmx_regs (regcache);
 487     }
 488   else
 489     {
 490       if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
 491         store_register (regcache, regno);
 492       else if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
 493         store_fpregister (regcache, regno);
 494       else if (arm_linux_has_wmmx_registers
 495                && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
 496         store_wmmx_regs (regcache);
 497     }
 498 }
 499
 500 /* Wrapper functions for the standard regset handling, used by
 501    thread debugging.  */
 502
 503 void
 504 fill_gregset (const struct regcache *regcache,
 505               gdb_gregset_t *gregsetp, int regno)
 506 {
 507   arm_linux_collect_gregset (NULL, regcache, regno, gregsetp, 0);
 508 }
 509
 510 void
 511 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
 512 {
 513   arm_linux_supply_gregset (NULL, regcache, -1, gregsetp, 0);
 514 }
 515
 516 void
 517 fill_fpregset (const struct regcache *regcache,
 518                gdb_fpregset_t *fpregsetp, int regno)
 519 {
 520   arm_linux_collect_nwfpe (NULL, regcache, regno, fpregsetp, 0);
 521 }
 522
 523 /* Fill GDB's register array with the floating-point register values
 524    in *fpregsetp.  */
 525
 526 void
 527 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
 528 {
 529   arm_linux_supply_nwfpe (NULL, regcache, -1, fpregsetp, 0);
 530 }
 531
 532 /* Fetch the thread-local storage pointer for libthread_db.  */
 533
 534 ps_err_e
 535 ps_get_thread_area (const struct ps_prochandle *ph,
 536                     lwpid_t lwpid, int idx, void **base)
 537 {
 538   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
 539     return PS_ERR;
 540
 541   /* IDX is the bias from the thread pointer to the beginning of the
 542      thread descriptor.  It has to be subtracted due to implementation
 543      quirks in libthread_db.  */
 544   *base = (void *) ((char *)*base - idx);
 545
 546   return PS_OK;
 547 }
 548
 549 static unsigned int
 550 get_linux_version (unsigned int *vmajor,
 551                    unsigned int *vminor,
 552                    unsigned int *vrelease)
 553 {
 554   struct utsname info;
 555   char *pmajor, *pminor, *prelease, *tail;
 556
 557   if (-1 == uname (&info))
 558     {
 559       warning (_("Unable to determine GNU/Linux version."));
 560       return -1;
 561     }
 562
 563   pmajor = strtok (info.release, ".");
 564   pminor = strtok (NULL, ".");
 565   prelease = strtok (NULL, ".");
 566
 567   *vmajor = (unsigned int) strtoul (pmajor, &tail, 0);
 568   *vminor = (unsigned int) strtoul (pminor, &tail, 0);
 569   *vrelease = (unsigned int) strtoul (prelease, &tail, 0);
 570
 571   return ((*vmajor << 16) | (*vminor << 8) | *vrelease);
 572 }
 573
 574 static LONGEST (*super_xfer_partial) (struct target_ops *, enum target_object,
 575                                       const char *, gdb_byte *, const gdb_byte *,
 576                                       ULONGEST, LONGEST);
 577
 578 static LONGEST
 579 arm_linux_xfer_partial (struct target_ops *ops,
 580                          enum target_object object,
 581                          const char *annex,
 582                          gdb_byte *readbuf, const gdb_byte *writebuf,
 583                          ULONGEST offset, LONGEST len)
 584 {
 585   if (object == TARGET_OBJECT_AVAILABLE_FEATURES)
 586     {
 587       if (annex != NULL && strcmp (annex, "target.xml") == 0)
 588         {
 589           int ret;
 590           char regbuf[IWMMXT_REGS_SIZE];
 591
 592           ret = ptrace (PTRACE_GETWMMXREGS, GET_THREAD_ID (inferior_ptid),
 593                         0, regbuf);
 594           if (ret < 0)
 595             arm_linux_has_wmmx_registers = 0;
 596           else
 597             arm_linux_has_wmmx_registers = 1;
 598
 599           if (arm_linux_has_wmmx_registers)
 600             annex = "arm-with-iwmmxt.xml";
 601           else
 602             return -1;
 603         }
 604
 605       return xml_builtin_xfer_partial (annex, readbuf, writebuf, offset, len);
 606     }
 607
 608   return super_xfer_partial (ops, object, annex, readbuf, writebuf,
 609                              offset, len);
 610 }
 611
 612 void _initialize_arm_linux_nat (void);
 613
 614 void
 615 _initialize_arm_linux_nat (void)
 616 {
 617   struct target_ops *t;
 618
 619   os_version = get_linux_version (&os_major, &os_minor, &os_release);
 620
 621   /* Fill in the generic GNU/Linux methods.  */
 622   t = linux_target ();
 623
 624   /* Add our register access methods.  */
 625   t->to_fetch_registers = arm_linux_fetch_inferior_registers;
 626   t->to_store_registers = arm_linux_store_inferior_registers;
 627
 628   /* Override the default to_xfer_partial.  */
 629   super_xfer_partial = t->to_xfer_partial;
 630   t->to_xfer_partial = arm_linux_xfer_partial;
 631
 632   /* Register the target.  */
 633   linux_nat_add_target (t);
 634 }