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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "inferior.h"
  22 #include "gdbcore.h"
  23 #include "gdb_string.h"
  24 #include "regcache.h"
  25 #include "target.h"
  26 #include "linux-nat.h"
  27 #include "target-descriptions.h"
  28 #include "xml-support.h"
  29
  30 #include "arm-tdep.h"
  31 #include "arm-linux-tdep.h"
  32
  33 #include <sys/user.h>
  34 #include <sys/ptrace.h>
  35 #include <sys/utsname.h>
  36 #include <sys/procfs.h>
  37
  38 /* Prototypes for supply_gregset etc. */
  39 #include "gregset.h"
  40
  41 /* Defines ps_err_e, struct ps_prochandle.  */
  42 #include "gdb_proc_service.h"
  43
  44 #ifndef PTRACE_GET_THREAD_AREA
  45 #define PTRACE_GET_THREAD_AREA 22
  46 #endif
  47
  48 #ifndef PTRACE_GETWMMXREGS
  49 #define PTRACE_GETWMMXREGS 18
  50 #define PTRACE_SETWMMXREGS 19
  51 #endif
  52
  53 /* A flag for whether the WMMX registers are available.  */
  54 static int arm_linux_has_wmmx_registers;
  55
  56 extern int arm_apcs_32;
  57
  58 /* The following variables are used to determine the version of the
  59    underlying GNU/Linux operating system.  Examples:
  60
  61    GNU/Linux 2.0.35             GNU/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 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
  75    case we may be tracing more than one process at a time.  In that
  76    case, inferior_ptid will contain the main process ID and the
  77    individual thread (process) ID.  get_thread_id () is used to get
  78    the thread id if it's available, and the process id otherwise.  */
  79
  80 int
  81 get_thread_id (ptid_t ptid)
  82 {
  83   int tid = TIDGET (ptid);
  84   if (0 == tid)
  85     tid = PIDGET (ptid);
  86   return tid;
  87 }
  88 #define GET_THREAD_ID(PTID)     get_thread_id (PTID)
  89
  90 /* Get the value of a particular register from the floating point
  91    state of the process and store it into regcache.  */
  92
  93 static void
  94 fetch_fpregister (struct regcache *regcache, int regno)
  95 {
  96   int ret, tid;
  97   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
  98
  99   /* Get the thread id for the ptrace call.  */
 100   tid = GET_THREAD_ID (inferior_ptid);
 101
 102   /* Read the floating point state.  */
 103   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 104   if (ret < 0)
 105     {
 106       warning (_("Unable to fetch floating point register."));
 107       return;
 108     }
 109
 110   /* Fetch fpsr.  */
 111   if (ARM_FPS_REGNUM == regno)
 112     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 113                          fp + NWFPE_FPSR_OFFSET);
 114
 115   /* Fetch the floating point register.  */
 116   if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
 117     supply_nwfpe_register (regcache, regno, fp);
 118 }
 119
 120 /* Get the whole floating point state of the process and store it
 121    into regcache.  */
 122
 123 static void
 124 fetch_fpregs (struct regcache *regcache)
 125 {
 126   int ret, regno, tid;
 127   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 128
 129   /* Get the thread id for the ptrace call.  */
 130   tid = GET_THREAD_ID (inferior_ptid);
 131
 132   /* Read the floating point state.  */
 133   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 134   if (ret < 0)
 135     {
 136       warning (_("Unable to fetch the floating point registers."));
 137       return;
 138     }
 139
 140   /* Fetch fpsr.  */
 141   regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 142                        fp + NWFPE_FPSR_OFFSET);
 143
 144   /* Fetch the floating point registers.  */
 145   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 146     supply_nwfpe_register (regcache, regno, fp);
 147 }
 148
 149 /* Save a particular register into the floating point state of the
 150    process using the contents from regcache.  */
 151
 152 static void
 153 store_fpregister (const struct regcache *regcache, int regno)
 154 {
 155   int ret, tid;
 156   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 157
 158   /* Get the thread id for the ptrace call.  */
 159   tid = GET_THREAD_ID (inferior_ptid);
 160
 161   /* Read the floating point state.  */
 162   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 163   if (ret < 0)
 164     {
 165       warning (_("Unable to fetch the floating point registers."));
 166       return;
 167     }
 168
 169   /* Store fpsr.  */
 170   if (ARM_FPS_REGNUM == regno && regcache_valid_p (regcache, ARM_FPS_REGNUM))
 171     regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
 172
 173   /* Store the floating point register.  */
 174   if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
 175     collect_nwfpe_register (regcache, regno, fp);
 176
 177   ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
 178   if (ret < 0)
 179     {
 180       warning (_("Unable to store floating point register."));
 181       return;
 182     }
 183 }
 184
 185 /* Save the whole floating point state of the process using
 186    the contents from regcache.  */
 187
 188 static void
 189 store_fpregs (const struct regcache *regcache)
 190 {
 191   int ret, regno, tid;
 192   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 193
 194   /* Get the thread id for the ptrace call.  */
 195   tid = GET_THREAD_ID (inferior_ptid);
 196
 197   /* Read the floating point state.  */
 198   ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 199   if (ret < 0)
 200     {
 201       warning (_("Unable to fetch the floating point registers."));
 202       return;
 203     }
 204
 205   /* Store fpsr.  */
 206   if (regcache_valid_p (regcache, ARM_FPS_REGNUM))
 207     regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
 208
 209   /* Store the floating point registers.  */
 210   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 211     if (regcache_valid_p (regcache, regno))
 212       collect_nwfpe_register (regcache, regno, fp);
 213
 214   ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
 215   if (ret < 0)
 216     {
 217       warning (_("Unable to store floating point registers."));
 218       return;
 219     }
 220 }
 221
 222 /* Fetch a general register of the process and store into
 223    regcache.  */
 224
 225 static void
 226 fetch_register (struct regcache *regcache, int regno)
 227 {
 228   int ret, tid;
 229   elf_gregset_t regs;
 230
 231   /* Get the thread id for the ptrace call.  */
 232   tid = GET_THREAD_ID (inferior_ptid);
 233
 234   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 235   if (ret < 0)
 236     {
 237       warning (_("Unable to fetch general register."));
 238       return;
 239     }
 240
 241   if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM)
 242     regcache_raw_supply (regcache, regno, (char *) &regs[regno]);
 243
 244   if (ARM_PS_REGNUM == regno)
 245     {
 246       if (arm_apcs_32)
 247         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 248                              (char *) &regs[ARM_CPSR_REGNUM]);
 249       else
 250         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 251                              (char *) &regs[ARM_PC_REGNUM]);
 252     }
 253
 254   if (ARM_PC_REGNUM == regno)
 255     {
 256       regs[ARM_PC_REGNUM] = gdbarch_addr_bits_remove
 257                               (current_gdbarch, regs[ARM_PC_REGNUM]);
 258       regcache_raw_supply (regcache, ARM_PC_REGNUM,
 259                            (char *) &regs[ARM_PC_REGNUM]);
 260     }
 261 }
 262
 263 /* Fetch all general registers of the process and store into
 264    regcache.  */
 265
 266 static void
 267 fetch_regs (struct regcache *regcache)
 268 {
 269   int ret, regno, tid;
 270   elf_gregset_t regs;
 271
 272   /* Get the thread id for the ptrace call.  */
 273   tid = GET_THREAD_ID (inferior_ptid);
 274
 275   ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 276   if (ret < 0)
 277     {
 278       warning (_("Unable to fetch general registers."));
 279       return;
 280     }
 281
 282   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 283     regcache_raw_supply (regcache, regno, (char *) &regs[regno]);
 284
 285   if (arm_apcs_32)
 286     regcache_raw_supply (regcache, ARM_PS_REGNUM,
 287                          (char *) &regs[ARM_CPSR_REGNUM]);
 288   else
 289     regcache_raw_supply (regcache, ARM_PS_REGNUM,
 290                          (char *) &regs[ARM_PC_REGNUM]);
 291
 292   regs[ARM_PC_REGNUM] = gdbarch_addr_bits_remove
 293                           (current_gdbarch, 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 }