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     {
 306       if (aarch64_linux_region_ok_for_watchpoint (addr, len))
 307         ret = aarch64_handle_watchpoint (targ_type, addr, len,
 308                                          1 /* is_insert */, state);
 309       else
 310         ret = -1;
 311     }
 312   else
 313     ret =
 314       aarch64_handle_breakpoint (targ_type, addr, len, 1 /* is_insert */,
 315                                  state);
 316
 317   if (show_debug_regs)
 318     aarch64_show_debug_reg_state (state, "insert_point", addr, len,
 319                                   targ_type);
 320
 321   return ret;
 322 }
 323
 324 /* Implementation of linux_target_ops method "remove_point".
 325
 326    It actually only records the info of the to-be-removed bp/wp,
 327    the actual removal will be done when threads are resumed.  */
 328
 329 static int
 330 aarch64_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
 331                       int len, struct raw_breakpoint *bp)
 332 {
 333   int ret;
 334   enum target_hw_bp_type targ_type;
 335   struct aarch64_debug_reg_state *state
 336     = aarch64_get_debug_reg_state (pid_of (current_thread));
 337
 338   if (show_debug_regs)
 339     fprintf (stderr, "remove_point on entry (addr=0x%08lx, len=%d)\n",
 340              (unsigned long) addr, len);
 341
 342   /* Determine the type from the raw breakpoint type.  */
 343   targ_type = raw_bkpt_type_to_target_hw_bp_type (type);
 344
 345   /* Set up state pointers.  */
 346   if (targ_type != hw_execute)
 347     ret =
 348       aarch64_handle_watchpoint (targ_type, addr, len, 0 /* is_insert */,
 349                                  state);
 350   else
 351     ret =
 352       aarch64_handle_breakpoint (targ_type, addr, len, 0 /* is_insert */,
 353                                  state);
 354
 355   if (show_debug_regs)
 356     aarch64_show_debug_reg_state (state, "remove_point", addr, len,
 357                                   targ_type);
 358
 359   return ret;
 360 }
 361
 362 /* Implementation of linux_target_ops method "stopped_data_address".  */
 363
 364 static CORE_ADDR
 365 aarch64_stopped_data_address (void)
 366 {
 367   siginfo_t siginfo;
 368   int pid, i;
 369   struct aarch64_debug_reg_state *state;
 370
 371   pid = lwpid_of (current_thread);
 372
 373   /* Get the siginfo.  */
 374   if (ptrace (PTRACE_GETSIGINFO, pid, NULL, &siginfo) != 0)
 375     return (CORE_ADDR) 0;
 376
 377   /* Need to be a hardware breakpoint/watchpoint trap.  */
 378   if (siginfo.si_signo != SIGTRAP
 379       || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
 380     return (CORE_ADDR) 0;
 381
 382   /* Check if the address matches any watched address.  */
 383   state = aarch64_get_debug_reg_state (pid_of (current_thread));
 384   for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
 385     {
 386       const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
 387       const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
 388       const CORE_ADDR addr_watch = state->dr_addr_wp[i];
 389       if (state->dr_ref_count_wp[i]
 390           && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
 391           && addr_trap >= addr_watch
 392           && addr_trap < addr_watch + len)
 393         return addr_trap;
 394     }
 395
 396   return (CORE_ADDR) 0;
 397 }
 398
 399 /* Implementation of linux_target_ops method "stopped_by_watchpoint".  */
 400
 401 static int
 402 aarch64_stopped_by_watchpoint (void)
 403 {
 404   if (aarch64_stopped_data_address () != 0)
 405     return 1;
 406   else
 407     return 0;
 408 }
 409
 410 /* Fetch the thread-local storage pointer for libthread_db.  */
 411
 412 ps_err_e
 413 ps_get_thread_area (const struct ps_prochandle *ph,
 414                     lwpid_t lwpid, int idx, void **base)
 415 {
 416   struct iovec iovec;
 417   uint64_t reg;
 418
 419   iovec.iov_base = &reg;
 420   iovec.iov_len = sizeof (reg);
 421
 422   if (ptrace (PTRACE_GETREGSET, lwpid, NT_ARM_TLS, &iovec) != 0)
 423     return PS_ERR;
 424
 425   /* IDX is the bias from the thread pointer to the beginning of the
 426      thread descriptor.  It has to be subtracted due to implementation
 427      quirks in libthread_db.  */
 428   *base = (void *) (reg - idx);
 429
 430   return PS_OK;
 431 }
 432
 433 /* Implementation of linux_target_ops method "siginfo_fixup".  */
 434
 435 static int
 436 aarch64_linux_siginfo_fixup (siginfo_t *native, void *inf, int direction)
 437 {
 438   /* Is the inferior 32-bit?  If so, then fixup the siginfo object.  */
 439   if (!is_64bit_tdesc ())
 440     {
 441       if (direction == 0)
 442         aarch64_compat_siginfo_from_siginfo ((struct compat_siginfo *) inf,
 443                                              native);
 444       else
 445         aarch64_siginfo_from_compat_siginfo (native,
 446                                              (struct compat_siginfo *) inf);
 447
 448       return 1;
 449     }
 450
 451   return 0;
 452 }
 453
 454 /* Implementation of linux_target_ops method "linux_new_process".  */
 455
 456 static struct arch_process_info *
 457 aarch64_linux_new_process (void)
 458 {
 459   struct arch_process_info *info = XCNEW (struct arch_process_info);
 460
 461   aarch64_init_debug_reg_state (&info->debug_reg_state);
 462
 463   return info;
 464 }
 465
 466 /* Implementation of linux_target_ops method "linux_new_fork".  */
 467
 468 static void
 469 aarch64_linux_new_fork (struct process_info *parent,
 470                         struct process_info *child)
 471 {
 472   /* These are allocated by linux_add_process.  */
 473   gdb_assert (parent->priv != NULL
 474               && parent->priv->arch_private != NULL);
 475   gdb_assert (child->priv != NULL
 476               && child->priv->arch_private != NULL);
 477
 478   /* Linux kernel before 2.6.33 commit
 479      72f674d203cd230426437cdcf7dd6f681dad8b0d
 480      will inherit hardware debug registers from parent
 481      on fork/vfork/clone.  Newer Linux kernels create such tasks with
 482      zeroed debug registers.
 483
 484      GDB core assumes the child inherits the watchpoints/hw
 485      breakpoints of the parent, and will remove them all from the
 486      forked off process.  Copy the debug registers mirrors into the
 487      new process so that all breakpoints and watchpoints can be
 488      removed together.  The debug registers mirror will become zeroed
 489      in the end before detaching the forked off process, thus making
 490      this compatible with older Linux kernels too.  */
 491
 492   *child->priv->arch_private = *parent->priv->arch_private;
 493 }
 494
 495 /* Return the right target description according to the ELF file of
 496    current thread.  */
 497
 498 static const struct target_desc *
 499 aarch64_linux_read_description (void)
 500 {
 501   unsigned int machine;
 502   int is_elf64;
 503   int tid;
 504
 505   tid = lwpid_of (current_thread);
 506
 507   is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine);
 508
 509   if (is_elf64)
 510     return tdesc_aarch64;
 511   else
 512     return tdesc_arm_with_neon;
 513 }
 514
 515 /* Implementation of linux_target_ops method "arch_setup".  */
 516
 517 static void
 518 aarch64_arch_setup (void)
 519 {
 520   current_process ()->tdesc = aarch64_linux_read_description ();
 521
 522   aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread));
 523 }
 524
 525 static struct regset_info aarch64_regsets[] =
 526 {
 527   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS,
 528     sizeof (struct user_pt_regs), GENERAL_REGS,
 529     aarch64_fill_gregset, aarch64_store_gregset },
 530   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_FPREGSET,
 531     sizeof (struct user_fpsimd_state), FP_REGS,
 532     aarch64_fill_fpregset, aarch64_store_fpregset
 533   },
 534   { 0, 0, 0, -1, -1, NULL, NULL }
 535 };
 536
 537 static struct regsets_info aarch64_regsets_info =
 538   {
 539     aarch64_regsets, /* regsets */
 540     0, /* num_regsets */
 541     NULL, /* disabled_regsets */
 542   };
 543
 544 static struct regs_info regs_info_aarch64 =
 545   {
 546     NULL, /* regset_bitmap */
 547     NULL, /* usrregs */
 548     &aarch64_regsets_info,
 549   };
 550
 551 /* Implementation of linux_target_ops method "regs_info".  */
 552
 553 static const struct regs_info *
 554 aarch64_regs_info (void)
 555 {
 556   if (is_64bit_tdesc ())
 557     return &regs_info_aarch64;
 558   else
 559     return &regs_info_aarch32;
 560 }
 561
 562 /* Implementation of linux_target_ops method "supports_tracepoints".  */
 563
 564 static int
 565 aarch64_supports_tracepoints (void)
 566 {
 567   if (current_thread == NULL)
 568     return 1;
 569   else
 570     {
 571       /* We don't support tracepoints on aarch32 now.  */
 572       return is_64bit_tdesc ();
 573     }
 574 }
 575
 576 /* Implementation of linux_target_ops method "supports_range_stepping".  */
 577
 578 static int
 579 aarch64_supports_range_stepping (void)
 580 {
 581   return 1;
 582 }
 583
 584 struct linux_target_ops the_low_target =
 585 {
 586   aarch64_arch_setup,
 587   aarch64_regs_info,
 588   aarch64_cannot_fetch_register,
 589   aarch64_cannot_store_register,
 590   NULL, /* fetch_register */
 591   aarch64_get_pc,
 592   aarch64_set_pc,
 593   (const unsigned char *) &aarch64_breakpoint,
 594   aarch64_breakpoint_len,
 595   NULL, /* breakpoint_reinsert_addr */
 596   0,    /* decr_pc_after_break */
 597   aarch64_breakpoint_at,
 598   aarch64_supports_z_point_type,
 599   aarch64_insert_point,
 600   aarch64_remove_point,
 601   aarch64_stopped_by_watchpoint,
 602   aarch64_stopped_data_address,
 603   NULL, /* collect_ptrace_register */
 604   NULL, /* supply_ptrace_register */
 605   aarch64_linux_siginfo_fixup,
 606   aarch64_linux_new_process,
 607   aarch64_linux_new_thread,
 608   aarch64_linux_new_fork,
 609   aarch64_linux_prepare_to_resume,
 610   NULL, /* process_qsupported */
 611   aarch64_supports_tracepoints,
 612   NULL, /* get_thread_area */
 613   NULL, /* install_fast_tracepoint_jump_pad */
 614   NULL, /* emit_ops */
 615   NULL, /* get_min_fast_tracepoint_insn_len */
 616   aarch64_supports_range_stepping,
 617 };
 618
 619 void
 620 initialize_low_arch (void)
 621 {
 622   init_registers_aarch64 ();
 623
 624   initialize_low_arch_aarch32 ();
 625
 626   initialize_regsets_info (&aarch64_regsets_info);
 627 }