gdb/gdbserver/linux-aarch64-low.c

   1 /* GNU/Linux/AArch64 specific low level interface, for the remote server for
   2    GDB.
   3
   4    Copyright (C) 2009-2015 Free Software Foundation, Inc.
   5    Contributed by ARM Ltd.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "server.h"
  23 #include "linux-low.h"
  24 #include "nat/aarch64-linux-hw-point.h"
  25 #include "linux-aarch32-low.h"
  26 #include "elf/common.h"
  27
  28 #include <signal.h>
  29 #include <sys/user.h>
  30 #include "nat/gdb_ptrace.h"
  31 #include <asm/ptrace.h>
  32 #include <sys/uio.h>
  33
  34 #include "gdb_proc_service.h"
  35
  36 /* Defined in auto-generated files.  */
  37 void init_registers_aarch64 (void);
  38 extern const struct target_desc *tdesc_aarch64;
  39
  40 #ifdef HAVE_SYS_REG_H
  41 #include <sys/reg.h>
  42 #endif
  43
  44 #define AARCH64_X_REGS_NUM 31
  45 #define AARCH64_V_REGS_NUM 32
  46 #define AARCH64_X0_REGNO    0
  47 #define AARCH64_SP_REGNO   31
  48 #define AARCH64_PC_REGNO   32
  49 #define AARCH64_CPSR_REGNO 33
  50 #define AARCH64_V0_REGNO   34
  51 #define AARCH64_FPSR_REGNO (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM)
  52 #define AARCH64_FPCR_REGNO (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM + 1)
  53
  54 #define AARCH64_NUM_REGS (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM + 2)
  55
  56 /* Per-process arch-specific data we want to keep.  */
  57
  58 struct arch_process_info
  59 {
  60   /* Hardware breakpoint/watchpoint data.
  61      The reason for them to be per-process rather than per-thread is
  62      due to the lack of information in the gdbserver environment;
  63      gdbserver is not told that whether a requested hardware
  64      breakpoint/watchpoint is thread specific or not, so it has to set
  65      each hw bp/wp for every thread in the current process.  The
  66      higher level bp/wp management in gdb will resume a thread if a hw
  67      bp/wp trap is not expected for it.  Since the hw bp/wp setting is
  68      same for each thread, it is reasonable for the data to live here.
  69      */
  70   struct aarch64_debug_reg_state debug_reg_state;
  71 };
  72
  73 /* Return true if the size of register 0 is 8 byte.  */
  74
  75 static int
  76 is_64bit_tdesc (void)
  77 {
  78   struct regcache *regcache = get_thread_regcache (current_thread, 0);
  79
  80   return register_size (regcache->tdesc, 0) == 8;
  81 }
  82
  83 /* Implementation of linux_target_ops method "cannot_store_register".  */
  84
  85 static int
  86 aarch64_cannot_store_register (int regno)
  87 {
  88   return regno >= AARCH64_NUM_REGS;
  89 }
  90
  91 /* Implementation of linux_target_ops method "cannot_fetch_register".  */
  92
  93 static int
  94 aarch64_cannot_fetch_register (int regno)
  95 {
  96   return regno >= AARCH64_NUM_REGS;
  97 }
  98
  99 static void
 100 aarch64_fill_gregset (struct regcache *regcache, void *buf)
 101 {
 102   struct user_pt_regs *regset = buf;
 103   int i;
 104
 105   for (i = 0; i < AARCH64_X_REGS_NUM; i++)
 106     collect_register (regcache, AARCH64_X0_REGNO + i, &regset->regs[i]);
 107   collect_register (regcache, AARCH64_SP_REGNO, &regset->sp);
 108   collect_register (regcache, AARCH64_PC_REGNO, &regset->pc);
 109   collect_register (regcache, AARCH64_CPSR_REGNO, &regset->pstate);
 110 }
 111
 112 static void
 113 aarch64_store_gregset (struct regcache *regcache, const void *buf)
 114 {
 115   const struct user_pt_regs *regset = buf;
 116   int i;
 117
 118   for (i = 0; i < AARCH64_X_REGS_NUM; i++)
 119     supply_register (regcache, AARCH64_X0_REGNO + i, &regset->regs[i]);
 120   supply_register (regcache, AARCH64_SP_REGNO, &regset->sp);
 121   supply_register (regcache, AARCH64_PC_REGNO, &regset->pc);
 122   supply_register (regcache, AARCH64_CPSR_REGNO, &regset->pstate);
 123 }
 124
 125 static void
 126 aarch64_fill_fpregset (struct regcache *regcache, void *buf)
 127 {
 128   struct user_fpsimd_state *regset = buf;
 129   int i;
 130
 131   for (i = 0; i < AARCH64_V_REGS_NUM; i++)
 132     collect_register (regcache, AARCH64_V0_REGNO + i, &regset->vregs[i]);
 133   collect_register (regcache, AARCH64_FPSR_REGNO, &regset->fpsr);
 134   collect_register (regcache, AARCH64_FPCR_REGNO, &regset->fpcr);
 135 }
 136
 137 static void
 138 aarch64_store_fpregset (struct regcache *regcache, const void *buf)
 139 {
 140   const struct user_fpsimd_state *regset = buf;
 141   int i;
 142
 143   for (i = 0; i < AARCH64_V_REGS_NUM; i++)
 144     supply_register (regcache, AARCH64_V0_REGNO + i, &regset->vregs[i]);
 145   supply_register (regcache, AARCH64_FPSR_REGNO, &regset->fpsr);
 146   supply_register (regcache, AARCH64_FPCR_REGNO, &regset->fpcr);
 147 }
 148
 149 /* Enable miscellaneous debugging output.  The name is historical - it
 150    was originally used to debug LinuxThreads support.  */
 151 extern int debug_threads;
 152
 153 /* Implementation of linux_target_ops method "get_pc".  */
 154
 155 static CORE_ADDR
 156 aarch64_get_pc (struct regcache *regcache)
 157 {
 158   if (register_size (regcache->tdesc, 0) == 8)
 159     {
 160       unsigned long pc;
 161
 162       collect_register_by_name (regcache, "pc", &pc);
 163       if (debug_threads)
 164         debug_printf ("stop pc is %08lx\n", pc);
 165       return pc;
 166     }
 167   else
 168     {
 169       unsigned int pc;
 170
 171       collect_register_by_name (regcache, "pc", &pc);
 172       if (debug_threads)
 173         debug_printf ("stop pc is %04x\n", pc);
 174       return pc;
 175     }
 176 }
 177
 178 /* Implementation of linux_target_ops method "set_pc".  */
 179
 180 static void
 181 aarch64_set_pc (struct regcache *regcache, CORE_ADDR pc)
 182 {
 183   if (register_size (regcache->tdesc, 0) == 8)
 184     {
 185       unsigned long newpc = pc;
 186       supply_register_by_name (regcache, "pc", &newpc);
 187     }
 188   else
 189     {
 190       unsigned int newpc = pc;
 191       supply_register_by_name (regcache, "pc", &newpc);
 192     }
 193 }
 194
 195 #define aarch64_breakpoint_len 4
 196
 197 /* AArch64 BRK software debug mode instruction.
 198    This instruction needs to match gdb/aarch64-tdep.c
 199    (aarch64_default_breakpoint).  */
 200 static const gdb_byte aarch64_breakpoint[] = {0x00, 0x00, 0x20, 0xd4};
 201
 202 /* Implementation of linux_target_ops method "breakpoint_at".  */
 203
 204 static int
 205 aarch64_breakpoint_at (CORE_ADDR where)
 206 {
 207   gdb_byte insn[aarch64_breakpoint_len];
 208
 209   (*the_target->read_memory) (where, (unsigned char *) &insn,
 210                               aarch64_breakpoint_len);
 211   if (memcmp (insn, aarch64_breakpoint, aarch64_breakpoint_len) == 0)
 212     return 1;
 213
 214   return 0;
 215 }
 216
 217 static void
 218 aarch64_init_debug_reg_state (struct aarch64_debug_reg_state *state)
 219 {
 220   int i;
 221
 222   for (i = 0; i < AARCH64_HBP_MAX_NUM; ++i)
 223     {
 224       state->dr_addr_bp[i] = 0;
 225       state->dr_ctrl_bp[i] = 0;
 226       state->dr_ref_count_bp[i] = 0;
 227     }
 228
 229   for (i = 0; i < AARCH64_HWP_MAX_NUM; ++i)
 230     {
 231       state->dr_addr_wp[i] = 0;
 232       state->dr_ctrl_wp[i] = 0;
 233       state->dr_ref_count_wp[i] = 0;
 234     }
 235 }
 236
 237 /* Return the pointer to the debug register state structure in the
 238    current process' arch-specific data area.  */
 239
 240 static struct aarch64_debug_reg_state *
 241 aarch64_get_debug_reg_state (pid_t pid)
 242 {
 243   struct process_info *proc = find_process_pid (pid);
 244
 245   return &proc->priv->arch_private->debug_reg_state;
 246 }
 247
 248 /* Implementation of linux_target_ops method "supports_z_point_type".  */
 249
 250 static int
 251 aarch64_supports_z_point_type (char z_type)
 252 {
 253   switch (z_type)
 254     {
 255     case Z_PACKET_SW_BP:
 256       {
 257         if (!extended_protocol && is_64bit_tdesc ())
 258           {
 259             /* Only enable Z0 packet in non-multi-arch debugging.  If
 260                extended protocol is used, don't enable Z0 packet because
 261                GDBserver may attach to 32-bit process.  */
 262             return 1;
 263           }
 264         else
 265           {
 266             /* Disable Z0 packet so that GDBserver doesn't have to handle
 267                different breakpoint instructions (aarch64, arm, thumb etc)
 268                in multi-arch debugging.  */
 269             return 0;
 270           }
 271       }
 272     case Z_PACKET_HW_BP:
 273     case Z_PACKET_WRITE_WP:
 274     case Z_PACKET_READ_WP:
 275     case Z_PACKET_ACCESS_WP:
 276       return 1;
 277     default:
 278       return 0;
 279     }
 280 }
 281
 282 /* Implementation of linux_target_ops method "insert_point".
 283
 284    It actually only records the info of the to-be-inserted bp/wp;
 285    the actual insertion will happen when threads are resumed.  */
 286
 287 static int
 288 aarch64_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
 289                       int len, struct raw_breakpoint *bp)
 290 {
 291   int ret;
 292   enum target_hw_bp_type targ_type;
 293   struct aarch64_debug_reg_state *state
 294     = aarch64_get_debug_reg_state (pid_of (current_thread));
 295
 296   if (show_debug_regs)
 297     fprintf (stderr, "insert_point on entry (addr=0x%08lx, len=%d)\n",
 298              (unsigned long) addr, len);
 299
 300   /* Determine the type from the raw breakpoint type.  */
 301   targ_type = raw_bkpt_type_to_target_hw_bp_type (type);
 302
 303   if (targ_type != hw_execute)
 304     ret =
 305       aarch64_handle_watchpoint (targ_type, addr, len, 1 /* is_insert */,
 306                                  state);
 307   else
 308     ret =
 309       aarch64_handle_breakpoint (targ_type, addr, len, 1 /* is_insert */,
 310                                  state);
 311
 312   if (show_debug_regs)
 313     aarch64_show_debug_reg_state (state, "insert_point", addr, len,
 314                                   targ_type);
 315
 316   return ret;
 317 }
 318
 319 /* Implementation of linux_target_ops method "remove_point".
 320
 321    It actually only records the info of the to-be-removed bp/wp,
 322    the actual removal will be done when threads are resumed.  */
 323
 324 static int
 325 aarch64_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
 326                       int len, struct raw_breakpoint *bp)
 327 {
 328   int ret;
 329   enum target_hw_bp_type targ_type;
 330   struct aarch64_debug_reg_state *state
 331     = aarch64_get_debug_reg_state (pid_of (current_thread));
 332
 333   if (show_debug_regs)
 334     fprintf (stderr, "remove_point on entry (addr=0x%08lx, len=%d)\n",
 335              (unsigned long) addr, len);
 336
 337   /* Determine the type from the raw breakpoint type.  */
 338   targ_type = raw_bkpt_type_to_target_hw_bp_type (type);
 339
 340   /* Set up state pointers.  */
 341   if (targ_type != hw_execute)
 342     ret =
 343       aarch64_handle_watchpoint (targ_type, addr, len, 0 /* is_insert */,
 344                                  state);
 345   else
 346     ret =
 347       aarch64_handle_breakpoint (targ_type, addr, len, 0 /* is_insert */,
 348                                  state);
 349
 350   if (show_debug_regs)
 351     aarch64_show_debug_reg_state (state, "remove_point", addr, len,
 352                                   targ_type);
 353
 354   return ret;
 355 }
 356
 357 /* Implementation of linux_target_ops method "stopped_data_address".  */
 358
 359 static CORE_ADDR
 360 aarch64_stopped_data_address (void)
 361 {
 362   siginfo_t siginfo;
 363   int pid, i;
 364   struct aarch64_debug_reg_state *state;
 365
 366   pid = lwpid_of (current_thread);
 367
 368   /* Get the siginfo.  */
 369   if (ptrace (PTRACE_GETSIGINFO, pid, NULL, &siginfo) != 0)
 370     return (CORE_ADDR) 0;
 371
 372   /* Need to be a hardware breakpoint/watchpoint trap.  */
 373   if (siginfo.si_signo != SIGTRAP
 374       || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
 375     return (CORE_ADDR) 0;
 376
 377   /* Check if the address matches any watched address.  */
 378   state = aarch64_get_debug_reg_state (pid_of (current_thread));
 379   for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
 380     {
 381       const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
 382       const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
 383       const CORE_ADDR addr_watch = state->dr_addr_wp[i];
 384       if (state->dr_ref_count_wp[i]
 385           && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
 386           && addr_trap >= addr_watch
 387           && addr_trap < addr_watch + len)
 388         return addr_trap;
 389     }
 390
 391   return (CORE_ADDR) 0;
 392 }
 393
 394 /* Implementation of linux_target_ops method "stopped_by_watchpoint".  */
 395
 396 static int
 397 aarch64_stopped_by_watchpoint (void)
 398 {
 399   if (aarch64_stopped_data_address () != 0)
 400     return 1;
 401   else
 402     return 0;
 403 }
 404
 405 /* Fetch the thread-local storage pointer for libthread_db.  */
 406
 407 ps_err_e
 408 ps_get_thread_area (const struct ps_prochandle *ph,
 409                     lwpid_t lwpid, int idx, void **base)
 410 {
 411   struct iovec iovec;
 412   uint64_t reg;
 413
 414   iovec.iov_base = &reg;
 415   iovec.iov_len = sizeof (reg);
 416
 417   if (ptrace (PTRACE_GETREGSET, lwpid, NT_ARM_TLS, &iovec) != 0)
 418     return PS_ERR;
 419
 420   /* IDX is the bias from the thread pointer to the beginning of the
 421      thread descriptor.  It has to be subtracted due to implementation
 422      quirks in libthread_db.  */
 423   *base = (void *) (reg - idx);
 424
 425   return PS_OK;
 426 }
 427
 428 /* Implementation of linux_target_ops method "linux_new_process".  */
 429
 430 static struct arch_process_info *
 431 aarch64_linux_new_process (void)
 432 {
 433   struct arch_process_info *info = xcalloc (1, sizeof (*info));
 434
 435   aarch64_init_debug_reg_state (&info->debug_reg_state);
 436
 437   return info;
 438 }
 439
 440 /* Implementation of linux_target_ops method "linux_new_thread".  */
 441
 442 static void
 443 aarch64_linux_new_thread (struct lwp_info *lwp)
 444 {
 445   struct arch_lwp_info *info = xcalloc (1, sizeof (*info));
 446
 447   /* Mark that all the hardware breakpoint/watchpoint register pairs
 448      for this thread need to be initialized (with data from
 449      aarch_process_info.debug_reg_state).  */
 450   DR_MARK_ALL_CHANGED (info->dr_changed_bp, aarch64_num_bp_regs);
 451   DR_MARK_ALL_CHANGED (info->dr_changed_wp, aarch64_num_wp_regs);
 452
 453   lwp->arch_private = info;
 454 }
 455
 456 /* Implementation of linux_target_ops method "linux_new_fork".  */
 457
 458 static void
 459 aarch64_linux_new_fork (struct process_info *parent,
 460                         struct process_info *child)
 461 {
 462   /* These are allocated by linux_add_process.  */
 463   gdb_assert (parent->priv != NULL
 464               && parent->priv->arch_private != NULL);
 465   gdb_assert (child->priv != NULL
 466               && child->priv->arch_private != NULL);
 467
 468   /* Linux kernel before 2.6.33 commit
 469      72f674d203cd230426437cdcf7dd6f681dad8b0d
 470      will inherit hardware debug registers from parent
 471      on fork/vfork/clone.  Newer Linux kernels create such tasks with
 472      zeroed debug registers.
 473
 474      GDB core assumes the child inherits the watchpoints/hw
 475      breakpoints of the parent, and will remove them all from the
 476      forked off process.  Copy the debug registers mirrors into the
 477      new process so that all breakpoints and watchpoints can be
 478      removed together.  The debug registers mirror will become zeroed
 479      in the end before detaching the forked off process, thus making
 480      this compatible with older Linux kernels too.  */
 481
 482   *child->priv->arch_private = *parent->priv->arch_private;
 483 }
 484
 485 /* Implementation of linux_target_ops method "linux_prepare_to_resume".
 486
 487    If the debug regs have changed, update the thread's copies.  */
 488
 489 static void
 490 aarch64_linux_prepare_to_resume (struct lwp_info *lwp)
 491 {
 492   struct arch_lwp_info *info = lwp_arch_private_info (lwp);
 493
 494   if (DR_HAS_CHANGED (info->dr_changed_bp)
 495       || DR_HAS_CHANGED (info->dr_changed_wp))
 496     {
 497       ptid_t ptid = ptid_of_lwp (lwp);
 498       int tid = ptid_get_lwp (ptid);
 499       struct aarch64_debug_reg_state *state
 500         = aarch64_get_debug_reg_state (ptid_get_pid (ptid));
 501
 502       if (show_debug_regs)
 503         fprintf (stderr, "prepare_to_resume thread %d\n", tid);
 504
 505       /* Watchpoints.  */
 506       if (DR_HAS_CHANGED (info->dr_changed_wp))
 507         {
 508           aarch64_linux_set_debug_regs (state, tid, 1);
 509           DR_CLEAR_CHANGED (info->dr_changed_wp);
 510         }
 511
 512       /* Breakpoints.  */
 513       if (DR_HAS_CHANGED (info->dr_changed_bp))
 514         {
 515           aarch64_linux_set_debug_regs (state, tid, 0);
 516           DR_CLEAR_CHANGED (info->dr_changed_bp);
 517         }
 518     }
 519 }
 520
 521 /* Return the right target description according to the ELF file of
 522    current thread.  */
 523
 524 static const struct target_desc *
 525 aarch64_linux_read_description (void)
 526 {
 527   unsigned int machine;
 528   int is_elf64;
 529   int tid;
 530
 531   tid = lwpid_of (current_thread);
 532
 533   is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine);
 534
 535   if (is_elf64)
 536     return tdesc_aarch64;
 537   else
 538     return tdesc_arm_with_neon;
 539 }
 540
 541 /* Implementation of linux_target_ops method "arch_setup".  */
 542
 543 static void
 544 aarch64_arch_setup (void)
 545 {
 546   current_process ()->tdesc = aarch64_linux_read_description ();
 547
 548   aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread));
 549 }
 550
 551 static struct regset_info aarch64_regsets[] =
 552 {
 553   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS,
 554     sizeof (struct user_pt_regs), GENERAL_REGS,
 555     aarch64_fill_gregset, aarch64_store_gregset },
 556   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_FPREGSET,
 557     sizeof (struct user_fpsimd_state), FP_REGS,
 558     aarch64_fill_fpregset, aarch64_store_fpregset
 559   },
 560   { 0, 0, 0, -1, -1, NULL, NULL }
 561 };
 562
 563 static struct regsets_info aarch64_regsets_info =
 564   {
 565     aarch64_regsets, /* regsets */
 566     0, /* num_regsets */
 567     NULL, /* disabled_regsets */
 568   };
 569
 570 static struct regs_info regs_info_aarch64 =
 571   {
 572     NULL, /* regset_bitmap */
 573     NULL, /* usrregs */
 574     &aarch64_regsets_info,
 575   };
 576
 577 /* Implementation of linux_target_ops method "regs_info".  */
 578
 579 static const struct regs_info *
 580 aarch64_regs_info (void)
 581 {
 582   if (is_64bit_tdesc ())
 583     return &regs_info_aarch64;
 584   else
 585     return &regs_info_aarch32;
 586 }
 587
 588 /* Implementation of linux_target_ops method "supports_tracepoints".  */
 589
 590 static int
 591 aarch64_supports_tracepoints (void)
 592 {
 593   if (current_thread == NULL)
 594     return 1;
 595   else
 596     {
 597       /* We don't support tracepoints on aarch32 now.  */
 598       return is_64bit_tdesc ();
 599     }
 600 }
 601
 602 /* Implementation of linux_target_ops method "supports_range_stepping".  */
 603
 604 static int
 605 aarch64_supports_range_stepping (void)
 606 {
 607   return 1;
 608 }
 609
 610 struct linux_target_ops the_low_target =
 611 {
 612   aarch64_arch_setup,
 613   aarch64_regs_info,
 614   aarch64_cannot_fetch_register,
 615   aarch64_cannot_store_register,
 616   NULL, /* fetch_register */
 617   aarch64_get_pc,
 618   aarch64_set_pc,
 619   (const unsigned char *) &aarch64_breakpoint,
 620   aarch64_breakpoint_len,
 621   NULL, /* breakpoint_reinsert_addr */
 622   0,    /* decr_pc_after_break */
 623   aarch64_breakpoint_at,
 624   aarch64_supports_z_point_type,
 625   aarch64_insert_point,
 626   aarch64_remove_point,
 627   aarch64_stopped_by_watchpoint,
 628   aarch64_stopped_data_address,
 629   NULL, /* collect_ptrace_register */
 630   NULL, /* supply_ptrace_register */
 631   NULL, /* siginfo_fixup */
 632   aarch64_linux_new_process,
 633   aarch64_linux_new_thread,
 634   aarch64_linux_new_fork,
 635   aarch64_linux_prepare_to_resume,
 636   NULL, /* process_qsupported */
 637   aarch64_supports_tracepoints,
 638   NULL, /* get_thread_area */
 639   NULL, /* install_fast_tracepoint_jump_pad */
 640   NULL, /* emit_ops */
 641   NULL, /* get_min_fast_tracepoint_insn_len */
 642   aarch64_supports_range_stepping,
 643 };
 644
 645 void
 646 initialize_low_arch (void)
 647 {
 648   init_registers_aarch64 ();
 649
 650   initialize_low_arch_aarch32 ();
 651
 652   initialize_regsets_info (&aarch64_regsets_info);
 653 }