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