1 /* GNU/Linux/AArch64 specific low level interface, for the remote server for
4 Copyright (C) 2009-2015 Free Software Foundation, Inc.
5 Contributed by ARM Ltd.
7 This file is part of GDB.
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.
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.
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/>. */
23 #include "linux-low.h"
24 #include "nat/aarch64-linux-hw-point.h"
25 #include "linux-aarch32-low.h"
26 #include "elf/common.h"
30 #include "nat/gdb_ptrace.h"
31 #include <asm/ptrace.h>
34 #include "gdb_proc_service.h"
36 /* Defined in auto-generated files. */
37 void init_registers_aarch64 (void);
38 extern const struct target_desc *tdesc_aarch64;
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)
54 #define AARCH64_NUM_REGS (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM + 2)
56 /* Per-process arch-specific data we want to keep. */
58 struct arch_process_info
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.
70 struct aarch64_debug_reg_state debug_reg_state;
73 /* Return true if the size of register 0 is 8 byte. */
78 struct regcache *regcache = get_thread_regcache (current_thread, 0);
80 return register_size (regcache->tdesc, 0) == 8;
83 /* Implementation of linux_target_ops method "cannot_store_register". */
86 aarch64_cannot_store_register (int regno)
88 return regno >= AARCH64_NUM_REGS;
91 /* Implementation of linux_target_ops method "cannot_fetch_register". */
94 aarch64_cannot_fetch_register (int regno)
96 return regno >= AARCH64_NUM_REGS;
100 aarch64_fill_gregset (struct regcache *regcache, void *buf)
102 struct user_pt_regs *regset = buf;
105 for (i = 0; i < AARCH64_X_REGS_NUM; i++)
106 collect_register (regcache, AARCH64_X0_REGNO + i, ®set->regs[i]);
107 collect_register (regcache, AARCH64_SP_REGNO, ®set->sp);
108 collect_register (regcache, AARCH64_PC_REGNO, ®set->pc);
109 collect_register (regcache, AARCH64_CPSR_REGNO, ®set->pstate);
113 aarch64_store_gregset (struct regcache *regcache, const void *buf)
115 const struct user_pt_regs *regset = buf;
118 for (i = 0; i < AARCH64_X_REGS_NUM; i++)
119 supply_register (regcache, AARCH64_X0_REGNO + i, ®set->regs[i]);
120 supply_register (regcache, AARCH64_SP_REGNO, ®set->sp);
121 supply_register (regcache, AARCH64_PC_REGNO, ®set->pc);
122 supply_register (regcache, AARCH64_CPSR_REGNO, ®set->pstate);
126 aarch64_fill_fpregset (struct regcache *regcache, void *buf)
128 struct user_fpsimd_state *regset = buf;
131 for (i = 0; i < AARCH64_V_REGS_NUM; i++)
132 collect_register (regcache, AARCH64_V0_REGNO + i, ®set->vregs[i]);
133 collect_register (regcache, AARCH64_FPSR_REGNO, ®set->fpsr);
134 collect_register (regcache, AARCH64_FPCR_REGNO, ®set->fpcr);
138 aarch64_store_fpregset (struct regcache *regcache, const void *buf)
140 const struct user_fpsimd_state *regset = buf;
143 for (i = 0; i < AARCH64_V_REGS_NUM; i++)
144 supply_register (regcache, AARCH64_V0_REGNO + i, ®set->vregs[i]);
145 supply_register (regcache, AARCH64_FPSR_REGNO, ®set->fpsr);
146 supply_register (regcache, AARCH64_FPCR_REGNO, ®set->fpcr);
149 /* Enable miscellaneous debugging output. The name is historical - it
150 was originally used to debug LinuxThreads support. */
151 extern int debug_threads;
153 /* Implementation of linux_target_ops method "get_pc". */
156 aarch64_get_pc (struct regcache *regcache)
158 if (register_size (regcache->tdesc, 0) == 8)
162 collect_register_by_name (regcache, "pc", &pc);
164 debug_printf ("stop pc is %08lx\n", pc);
171 collect_register_by_name (regcache, "pc", &pc);
173 debug_printf ("stop pc is %04x\n", pc);
178 /* Implementation of linux_target_ops method "set_pc". */
181 aarch64_set_pc (struct regcache *regcache, CORE_ADDR pc)
183 if (register_size (regcache->tdesc, 0) == 8)
185 unsigned long newpc = pc;
186 supply_register_by_name (regcache, "pc", &newpc);
190 unsigned int newpc = pc;
191 supply_register_by_name (regcache, "pc", &newpc);
195 #define aarch64_breakpoint_len 4
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};
202 /* Implementation of linux_target_ops method "breakpoint_at". */
205 aarch64_breakpoint_at (CORE_ADDR where)
207 gdb_byte insn[aarch64_breakpoint_len];
209 (*the_target->read_memory) (where, (unsigned char *) &insn,
210 aarch64_breakpoint_len);
211 if (memcmp (insn, aarch64_breakpoint, aarch64_breakpoint_len) == 0)
218 aarch64_init_debug_reg_state (struct aarch64_debug_reg_state *state)
222 for (i = 0; i < AARCH64_HBP_MAX_NUM; ++i)
224 state->dr_addr_bp[i] = 0;
225 state->dr_ctrl_bp[i] = 0;
226 state->dr_ref_count_bp[i] = 0;
229 for (i = 0; i < AARCH64_HWP_MAX_NUM; ++i)
231 state->dr_addr_wp[i] = 0;
232 state->dr_ctrl_wp[i] = 0;
233 state->dr_ref_count_wp[i] = 0;
237 struct aarch64_dr_update_callback_param
243 /* Callback for iterate_over_lwps. Records the
244 information about the change of one hardware breakpoint/watchpoint
245 setting for the thread LWP.
246 The information is passed in via PTR.
247 N.B. The actual updating of hardware debug registers is not
248 carried out until the moment the thread is resumed. */
251 debug_reg_change_callback (struct lwp_info *lwp, void *ptr)
253 struct aarch64_dr_update_callback_param *param_p
254 = (struct aarch64_dr_update_callback_param *) ptr;
255 int pid = pid_of (lwp->thread);
256 int idx = param_p->idx;
257 int is_watchpoint = param_p->is_watchpoint;
258 struct arch_lwp_info *info = lwp->arch_private;
259 dr_changed_t *dr_changed_ptr;
260 dr_changed_t dr_changed;
264 fprintf (stderr, "debug_reg_change_callback: \n\tOn entry:\n");
265 fprintf (stderr, "\tpid%d, dr_changed_bp=0x%llx, "
266 "dr_changed_wp=0x%llx\n",
267 pid, info->dr_changed_bp,
268 info->dr_changed_wp);
271 dr_changed_ptr = is_watchpoint ? &info->dr_changed_wp
272 : &info->dr_changed_bp;
273 dr_changed = *dr_changed_ptr;
276 && (idx <= (is_watchpoint ? aarch64_num_wp_regs
277 : aarch64_num_bp_regs)));
279 /* The following assertion is not right, as there can be changes
280 that have not been made to the hardware debug registers
281 before new changes overwrite the old ones. This can happen,
282 for instance, when the breakpoint/watchpoint hit one of the
283 threads and the user enters continue; then what happens is:
284 1) all breakpoints/watchpoints are removed for all threads;
285 2) a single step is carried out for the thread that was hit;
286 3) all of the points are inserted again for all threads;
287 4) all threads are resumed.
288 The 2nd step will only affect the one thread in which the
289 bp/wp was hit, which means only that one thread is resumed;
290 remember that the actual updating only happen in
291 aarch64_linux_prepare_to_resume, so other threads remain
292 stopped during the removal and insertion of bp/wp. Therefore
293 for those threads, the change of insertion of the bp/wp
294 overwrites that of the earlier removals. (The situation may
295 be different when bp/wp is steppable, or in the non-stop
297 /* gdb_assert (DR_N_HAS_CHANGED (dr_changed, idx) == 0); */
299 /* The actual update is done later just before resuming the lwp,
300 we just mark that one register pair needs updating. */
301 DR_MARK_N_CHANGED (dr_changed, idx);
302 *dr_changed_ptr = dr_changed;
304 /* If the lwp isn't stopped, force it to momentarily pause, so
305 we can update its debug registers. */
307 linux_stop_lwp (lwp);
311 fprintf (stderr, "\tOn exit:\n\tpid%d, dr_changed_bp=0x%llx, "
312 "dr_changed_wp=0x%llx\n",
313 pid, info->dr_changed_bp,
314 info->dr_changed_wp);
320 /* Notify each thread that their IDXth breakpoint/watchpoint register
321 pair needs to be updated. The message will be recorded in each
322 thread's arch-specific data area, the actual updating will be done
323 when the thread is resumed. */
326 aarch64_notify_debug_reg_change (const struct aarch64_debug_reg_state *state,
327 int is_watchpoint, unsigned int idx)
329 struct aarch64_dr_update_callback_param param;
330 ptid_t pid_ptid = pid_to_ptid (pid_of (current_thread));
332 param.is_watchpoint = is_watchpoint;
335 iterate_over_lwps (pid_ptid, debug_reg_change_callback, (void *) ¶m);
339 /* Return the pointer to the debug register state structure in the
340 current process' arch-specific data area. */
342 static struct aarch64_debug_reg_state *
343 aarch64_get_debug_reg_state ()
345 struct process_info *proc;
347 proc = current_process ();
348 return &proc->priv->arch_private->debug_reg_state;
351 /* Implementation of linux_target_ops method "supports_z_point_type". */
354 aarch64_supports_z_point_type (char z_type)
360 if (!extended_protocol && is_64bit_tdesc ())
362 /* Only enable Z0 packet in non-multi-arch debugging. If
363 extended protocol is used, don't enable Z0 packet because
364 GDBserver may attach to 32-bit process. */
369 /* Disable Z0 packet so that GDBserver doesn't have to handle
370 different breakpoint instructions (aarch64, arm, thumb etc)
371 in multi-arch debugging. */
376 case Z_PACKET_WRITE_WP:
377 case Z_PACKET_READ_WP:
378 case Z_PACKET_ACCESS_WP:
385 /* Implementation of linux_target_ops method "insert_point".
387 It actually only records the info of the to-be-inserted bp/wp;
388 the actual insertion will happen when threads are resumed. */
391 aarch64_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
392 int len, struct raw_breakpoint *bp)
395 enum target_hw_bp_type targ_type;
396 struct aarch64_debug_reg_state *state = aarch64_get_debug_reg_state ();
399 fprintf (stderr, "insert_point on entry (addr=0x%08lx, len=%d)\n",
400 (unsigned long) addr, len);
402 /* Determine the type from the raw breakpoint type. */
403 targ_type = raw_bkpt_type_to_target_hw_bp_type (type);
405 if (targ_type != hw_execute)
407 aarch64_handle_watchpoint (targ_type, addr, len, 1 /* is_insert */,
411 aarch64_handle_breakpoint (targ_type, addr, len, 1 /* is_insert */,
415 aarch64_show_debug_reg_state (aarch64_get_debug_reg_state (),
416 "insert_point", addr, len, targ_type);
421 /* Implementation of linux_target_ops method "remove_point".
423 It actually only records the info of the to-be-removed bp/wp,
424 the actual removal will be done when threads are resumed. */
427 aarch64_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
428 int len, struct raw_breakpoint *bp)
431 enum target_hw_bp_type targ_type;
432 struct aarch64_debug_reg_state *state = aarch64_get_debug_reg_state ();
435 fprintf (stderr, "remove_point on entry (addr=0x%08lx, len=%d)\n",
436 (unsigned long) addr, len);
438 /* Determine the type from the raw breakpoint type. */
439 targ_type = raw_bkpt_type_to_target_hw_bp_type (type);
441 /* Set up state pointers. */
442 if (targ_type != hw_execute)
444 aarch64_handle_watchpoint (targ_type, addr, len, 0 /* is_insert */,
448 aarch64_handle_breakpoint (targ_type, addr, len, 0 /* is_insert */,
452 aarch64_show_debug_reg_state (aarch64_get_debug_reg_state (),
453 "remove_point", addr, len, targ_type);
458 /* Implementation of linux_target_ops method "stopped_data_address". */
461 aarch64_stopped_data_address (void)
465 struct aarch64_debug_reg_state *state;
467 pid = lwpid_of (current_thread);
469 /* Get the siginfo. */
470 if (ptrace (PTRACE_GETSIGINFO, pid, NULL, &siginfo) != 0)
471 return (CORE_ADDR) 0;
473 /* Need to be a hardware breakpoint/watchpoint trap. */
474 if (siginfo.si_signo != SIGTRAP
475 || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
476 return (CORE_ADDR) 0;
478 /* Check if the address matches any watched address. */
479 state = aarch64_get_debug_reg_state ();
480 for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
482 const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
483 const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
484 const CORE_ADDR addr_watch = state->dr_addr_wp[i];
485 if (state->dr_ref_count_wp[i]
486 && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
487 && addr_trap >= addr_watch
488 && addr_trap < addr_watch + len)
492 return (CORE_ADDR) 0;
495 /* Implementation of linux_target_ops method "stopped_by_watchpoint". */
498 aarch64_stopped_by_watchpoint (void)
500 if (aarch64_stopped_data_address () != 0)
506 /* Fetch the thread-local storage pointer for libthread_db. */
509 ps_get_thread_area (const struct ps_prochandle *ph,
510 lwpid_t lwpid, int idx, void **base)
515 iovec.iov_base = ®
516 iovec.iov_len = sizeof (reg);
518 if (ptrace (PTRACE_GETREGSET, lwpid, NT_ARM_TLS, &iovec) != 0)
521 /* IDX is the bias from the thread pointer to the beginning of the
522 thread descriptor. It has to be subtracted due to implementation
523 quirks in libthread_db. */
524 *base = (void *) (reg - idx);
529 /* Implementation of linux_target_ops method "linux_new_process". */
531 static struct arch_process_info *
532 aarch64_linux_new_process (void)
534 struct arch_process_info *info = xcalloc (1, sizeof (*info));
536 aarch64_init_debug_reg_state (&info->debug_reg_state);
541 /* Implementation of linux_target_ops method "linux_new_thread". */
544 aarch64_linux_new_thread (struct lwp_info *lwp)
546 struct arch_lwp_info *info = xcalloc (1, sizeof (*info));
548 /* Mark that all the hardware breakpoint/watchpoint register pairs
549 for this thread need to be initialized (with data from
550 aarch_process_info.debug_reg_state). */
551 DR_MARK_ALL_CHANGED (info->dr_changed_bp, aarch64_num_bp_regs);
552 DR_MARK_ALL_CHANGED (info->dr_changed_wp, aarch64_num_wp_regs);
554 lwp->arch_private = info;
557 /* Implementation of linux_target_ops method "linux_new_fork". */
560 aarch64_linux_new_fork (struct process_info *parent,
561 struct process_info *child)
563 /* These are allocated by linux_add_process. */
564 gdb_assert (parent->priv != NULL
565 && parent->priv->arch_private != NULL);
566 gdb_assert (child->priv != NULL
567 && child->priv->arch_private != NULL);
569 /* Linux kernel before 2.6.33 commit
570 72f674d203cd230426437cdcf7dd6f681dad8b0d
571 will inherit hardware debug registers from parent
572 on fork/vfork/clone. Newer Linux kernels create such tasks with
573 zeroed debug registers.
575 GDB core assumes the child inherits the watchpoints/hw
576 breakpoints of the parent, and will remove them all from the
577 forked off process. Copy the debug registers mirrors into the
578 new process so that all breakpoints and watchpoints can be
579 removed together. The debug registers mirror will become zeroed
580 in the end before detaching the forked off process, thus making
581 this compatible with older Linux kernels too. */
583 *child->priv->arch_private = *parent->priv->arch_private;
586 /* Implementation of linux_target_ops method "linux_prepare_to_resume".
588 If the debug regs have changed, update the thread's copies. */
591 aarch64_linux_prepare_to_resume (struct lwp_info *lwp)
593 struct thread_info *thread = get_lwp_thread (lwp);
594 ptid_t ptid = ptid_of (thread);
595 struct arch_lwp_info *info = lwp->arch_private;
597 if (DR_HAS_CHANGED (info->dr_changed_bp)
598 || DR_HAS_CHANGED (info->dr_changed_wp))
600 int tid = ptid_get_lwp (ptid);
601 struct process_info *proc = find_process_pid (ptid_get_pid (ptid));
602 struct aarch64_debug_reg_state *state
603 = &proc->priv->arch_private->debug_reg_state;
606 fprintf (stderr, "prepare_to_resume thread %ld\n", lwpid_of (thread));
609 if (DR_HAS_CHANGED (info->dr_changed_wp))
611 aarch64_linux_set_debug_regs (state, tid, 1);
612 DR_CLEAR_CHANGED (info->dr_changed_wp);
616 if (DR_HAS_CHANGED (info->dr_changed_bp))
618 aarch64_linux_set_debug_regs (state, tid, 0);
619 DR_CLEAR_CHANGED (info->dr_changed_bp);
624 /* Return the right target description according to the ELF file of
627 static const struct target_desc *
628 aarch64_linux_read_description (void)
630 unsigned int machine;
634 tid = lwpid_of (current_thread);
636 is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine);
639 return tdesc_aarch64;
641 return tdesc_arm_with_neon;
644 /* Implementation of linux_target_ops method "arch_setup". */
647 aarch64_arch_setup (void)
649 current_process ()->tdesc = aarch64_linux_read_description ();
651 aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread));
654 static struct regset_info aarch64_regsets[] =
656 { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS,
657 sizeof (struct user_pt_regs), GENERAL_REGS,
658 aarch64_fill_gregset, aarch64_store_gregset },
659 { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_FPREGSET,
660 sizeof (struct user_fpsimd_state), FP_REGS,
661 aarch64_fill_fpregset, aarch64_store_fpregset
663 { 0, 0, 0, -1, -1, NULL, NULL }
666 static struct regsets_info aarch64_regsets_info =
668 aarch64_regsets, /* regsets */
670 NULL, /* disabled_regsets */
673 static struct regs_info regs_info_aarch64 =
675 NULL, /* regset_bitmap */
677 &aarch64_regsets_info,
680 /* Implementation of linux_target_ops method "regs_info". */
682 static const struct regs_info *
683 aarch64_regs_info (void)
685 if (is_64bit_tdesc ())
686 return ®s_info_aarch64;
688 return ®s_info_aarch32;
691 /* Implementation of linux_target_ops method "supports_tracepoints". */
694 aarch64_supports_tracepoints (void)
696 if (current_thread == NULL)
700 /* We don't support tracepoints on aarch32 now. */
701 return is_64bit_tdesc ();
705 /* Implementation of linux_target_ops method "supports_range_stepping". */
708 aarch64_supports_range_stepping (void)
713 struct linux_target_ops the_low_target =
717 aarch64_cannot_fetch_register,
718 aarch64_cannot_store_register,
719 NULL, /* fetch_register */
722 (const unsigned char *) &aarch64_breakpoint,
723 aarch64_breakpoint_len,
724 NULL, /* breakpoint_reinsert_addr */
725 0, /* decr_pc_after_break */
726 aarch64_breakpoint_at,
727 aarch64_supports_z_point_type,
728 aarch64_insert_point,
729 aarch64_remove_point,
730 aarch64_stopped_by_watchpoint,
731 aarch64_stopped_data_address,
732 NULL, /* collect_ptrace_register */
733 NULL, /* supply_ptrace_register */
734 NULL, /* siginfo_fixup */
735 aarch64_linux_new_process,
736 aarch64_linux_new_thread,
737 aarch64_linux_new_fork,
738 aarch64_linux_prepare_to_resume,
739 NULL, /* process_qsupported */
740 aarch64_supports_tracepoints,
741 NULL, /* get_thread_area */
742 NULL, /* install_fast_tracepoint_jump_pad */
744 NULL, /* get_min_fast_tracepoint_insn_len */
745 aarch64_supports_range_stepping,
749 initialize_low_arch (void)
751 init_registers_aarch64 ();
753 initialize_low_arch_aarch32 ();
755 initialize_regsets_info (&aarch64_regsets_info);