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_fork".  */
 442
 443 static void
 444 aarch64_linux_new_fork (struct process_info *parent,
 445                         struct process_info *child)
 446 {
 447   /* These are allocated by linux_add_process.  */
 448   gdb_assert (parent->priv != NULL
 449               && parent->priv->arch_private != NULL);
 450   gdb_assert (child->priv != NULL
 451               && child->priv->arch_private != NULL);
 452
 453   /* Linux kernel before 2.6.33 commit
 454      72f674d203cd230426437cdcf7dd6f681dad8b0d
 455      will inherit hardware debug registers from parent
 456      on fork/vfork/clone.  Newer Linux kernels create such tasks with
 457      zeroed debug registers.
 458
 459      GDB core assumes the child inherits the watchpoints/hw
 460      breakpoints of the parent, and will remove them all from the
 461      forked off process.  Copy the debug registers mirrors into the
 462      new process so that all breakpoints and watchpoints can be
 463      removed together.  The debug registers mirror will become zeroed
 464      in the end before detaching the forked off process, thus making
 465      this compatible with older Linux kernels too.  */
 466
 467   *child->priv->arch_private = *parent->priv->arch_private;
 468 }
 469
 470 /* Return the right target description according to the ELF file of
 471    current thread.  */
 472
 473 static const struct target_desc *
 474 aarch64_linux_read_description (void)
 475 {
 476   unsigned int machine;
 477   int is_elf64;
 478   int tid;
 479
 480   tid = lwpid_of (current_thread);
 481
 482   is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine);
 483
 484   if (is_elf64)
 485     return tdesc_aarch64;
 486   else
 487     return tdesc_arm_with_neon;
 488 }
 489
 490 /* Implementation of linux_target_ops method "arch_setup".  */
 491
 492 static void
 493 aarch64_arch_setup (void)
 494 {
 495   current_process ()->tdesc = aarch64_linux_read_description ();
 496
 497   aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread));
 498 }
 499
 500 static struct regset_info aarch64_regsets[] =
 501 {
 502   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS,
 503     sizeof (struct user_pt_regs), GENERAL_REGS,
 504     aarch64_fill_gregset, aarch64_store_gregset },
 505   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_FPREGSET,
 506     sizeof (struct user_fpsimd_state), FP_REGS,
 507     aarch64_fill_fpregset, aarch64_store_fpregset
 508   },
 509   { 0, 0, 0, -1, -1, NULL, NULL }
 510 };
 511
 512 static struct regsets_info aarch64_regsets_info =
 513   {
 514     aarch64_regsets, /* regsets */
 515     0, /* num_regsets */
 516     NULL, /* disabled_regsets */
 517   };
 518
 519 static struct regs_info regs_info_aarch64 =
 520   {
 521     NULL, /* regset_bitmap */
 522     NULL, /* usrregs */
 523     &aarch64_regsets_info,
 524   };
 525
 526 /* Implementation of linux_target_ops method "regs_info".  */
 527
 528 static const struct regs_info *
 529 aarch64_regs_info (void)
 530 {
 531   if (is_64bit_tdesc ())
 532     return &regs_info_aarch64;
 533   else
 534     return &regs_info_aarch32;
 535 }
 536
 537 /* Implementation of linux_target_ops method "supports_tracepoints".  */
 538
 539 static int
 540 aarch64_supports_tracepoints (void)
 541 {
 542   if (current_thread == NULL)
 543     return 1;
 544   else
 545     {
 546       /* We don't support tracepoints on aarch32 now.  */
 547       return is_64bit_tdesc ();
 548     }
 549 }
 550
 551 /* Implementation of linux_target_ops method "supports_range_stepping".  */
 552
 553 static int
 554 aarch64_supports_range_stepping (void)
 555 {
 556   return 1;
 557 }
 558
 559 struct linux_target_ops the_low_target =
 560 {
 561   aarch64_arch_setup,
 562   aarch64_regs_info,
 563   aarch64_cannot_fetch_register,
 564   aarch64_cannot_store_register,
 565   NULL, /* fetch_register */
 566   aarch64_get_pc,
 567   aarch64_set_pc,
 568   (const unsigned char *) &aarch64_breakpoint,
 569   aarch64_breakpoint_len,
 570   NULL, /* breakpoint_reinsert_addr */
 571   0,    /* decr_pc_after_break */
 572   aarch64_breakpoint_at,
 573   aarch64_supports_z_point_type,
 574   aarch64_insert_point,
 575   aarch64_remove_point,
 576   aarch64_stopped_by_watchpoint,
 577   aarch64_stopped_data_address,
 578   NULL, /* collect_ptrace_register */
 579   NULL, /* supply_ptrace_register */
 580   NULL, /* siginfo_fixup */
 581   aarch64_linux_new_process,
 582   aarch64_linux_new_thread,
 583   aarch64_linux_new_fork,
 584   aarch64_linux_prepare_to_resume,
 585   NULL, /* process_qsupported */
 586   aarch64_supports_tracepoints,
 587   NULL, /* get_thread_area */
 588   NULL, /* install_fast_tracepoint_jump_pad */
 589   NULL, /* emit_ops */
 590   NULL, /* get_min_fast_tracepoint_insn_len */
 591   aarch64_supports_range_stepping,
 592 };
 593
 594 void
 595 initialize_low_arch (void)
 596 {
 597   init_registers_aarch64 ();
 598
 599   initialize_low_arch_aarch32 ();
 600
 601   initialize_regsets_info (&aarch64_regsets_info);
 602 }