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 /* Return the pointer to the debug register state structure in the
238 current process' arch-specific data area. */
240 static struct aarch64_debug_reg_state
*
241 aarch64_get_debug_reg_state (pid_t pid
)
243 struct process_info
*proc
= find_process_pid (pid
);
245 return &proc
->priv
->arch_private
->debug_reg_state
;
248 /* Implementation of linux_target_ops method "supports_z_point_type". */
251 aarch64_supports_z_point_type (char z_type
)
257 if (!extended_protocol
&& is_64bit_tdesc ())
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. */
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. */
273 case Z_PACKET_WRITE_WP
:
274 case Z_PACKET_READ_WP
:
275 case Z_PACKET_ACCESS_WP
:
282 /* Implementation of linux_target_ops method "insert_point".
284 It actually only records the info of the to-be-inserted bp/wp;
285 the actual insertion will happen when threads are resumed. */
288 aarch64_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
289 int len
, struct raw_breakpoint
*bp
)
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
));
297 fprintf (stderr
, "insert_point on entry (addr=0x%08lx, len=%d)\n",
298 (unsigned long) addr
, len
);
300 /* Determine the type from the raw breakpoint type. */
301 targ_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
303 if (targ_type
!= hw_execute
)
305 aarch64_handle_watchpoint (targ_type
, addr
, len
, 1 /* is_insert */,
309 aarch64_handle_breakpoint (targ_type
, addr
, len
, 1 /* is_insert */,
313 aarch64_show_debug_reg_state (state
, "insert_point", addr
, len
,
319 /* Implementation of linux_target_ops method "remove_point".
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. */
325 aarch64_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
326 int len
, struct raw_breakpoint
*bp
)
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
));
334 fprintf (stderr
, "remove_point on entry (addr=0x%08lx, len=%d)\n",
335 (unsigned long) addr
, len
);
337 /* Determine the type from the raw breakpoint type. */
338 targ_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
340 /* Set up state pointers. */
341 if (targ_type
!= hw_execute
)
343 aarch64_handle_watchpoint (targ_type
, addr
, len
, 0 /* is_insert */,
347 aarch64_handle_breakpoint (targ_type
, addr
, len
, 0 /* is_insert */,
351 aarch64_show_debug_reg_state (state
, "remove_point", addr
, len
,
357 /* Implementation of linux_target_ops method "stopped_data_address". */
360 aarch64_stopped_data_address (void)
364 struct aarch64_debug_reg_state
*state
;
366 pid
= lwpid_of (current_thread
);
368 /* Get the siginfo. */
369 if (ptrace (PTRACE_GETSIGINFO
, pid
, NULL
, &siginfo
) != 0)
370 return (CORE_ADDR
) 0;
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;
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
)
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
)
391 return (CORE_ADDR
) 0;
394 /* Implementation of linux_target_ops method "stopped_by_watchpoint". */
397 aarch64_stopped_by_watchpoint (void)
399 if (aarch64_stopped_data_address () != 0)
405 /* Fetch the thread-local storage pointer for libthread_db. */
408 ps_get_thread_area (const struct ps_prochandle
*ph
,
409 lwpid_t lwpid
, int idx
, void **base
)
414 iovec
.iov_base
= ®
;
415 iovec
.iov_len
= sizeof (reg
);
417 if (ptrace (PTRACE_GETREGSET
, lwpid
, NT_ARM_TLS
, &iovec
) != 0)
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
);
428 /* Implementation of linux_target_ops method "linux_new_process". */
430 static struct arch_process_info
*
431 aarch64_linux_new_process (void)
433 struct arch_process_info
*info
= xcalloc (1, sizeof (*info
));
435 aarch64_init_debug_reg_state (&info
->debug_reg_state
);
440 /* Implementation of linux_target_ops method "linux_new_thread". */
443 aarch64_linux_new_thread (struct lwp_info
*lwp
)
445 struct arch_lwp_info
*info
= xcalloc (1, sizeof (*info
));
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
);
453 lwp
->arch_private
= info
;
456 /* Implementation of linux_target_ops method "linux_new_fork". */
459 aarch64_linux_new_fork (struct process_info
*parent
,
460 struct process_info
*child
)
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
);
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.
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. */
482 *child
->priv
->arch_private
= *parent
->priv
->arch_private
;
485 /* Implementation of linux_target_ops method "linux_prepare_to_resume".
487 If the debug regs have changed, update the thread's copies. */
490 aarch64_linux_prepare_to_resume (struct lwp_info
*lwp
)
492 struct thread_info
*thread
= get_lwp_thread (lwp
);
493 ptid_t ptid
= ptid_of (thread
);
494 struct arch_lwp_info
*info
= lwp
->arch_private
;
496 if (DR_HAS_CHANGED (info
->dr_changed_bp
)
497 || DR_HAS_CHANGED (info
->dr_changed_wp
))
499 int tid
= ptid_get_lwp (ptid
);
500 struct process_info
*proc
= find_process_pid (ptid_get_pid (ptid
));
501 struct aarch64_debug_reg_state
*state
502 = &proc
->priv
->arch_private
->debug_reg_state
;
505 fprintf (stderr
, "prepare_to_resume thread %ld\n", lwpid_of (thread
));
508 if (DR_HAS_CHANGED (info
->dr_changed_wp
))
510 aarch64_linux_set_debug_regs (state
, tid
, 1);
511 DR_CLEAR_CHANGED (info
->dr_changed_wp
);
515 if (DR_HAS_CHANGED (info
->dr_changed_bp
))
517 aarch64_linux_set_debug_regs (state
, tid
, 0);
518 DR_CLEAR_CHANGED (info
->dr_changed_bp
);
523 /* Return the right target description according to the ELF file of
526 static const struct target_desc
*
527 aarch64_linux_read_description (void)
529 unsigned int machine
;
533 tid
= lwpid_of (current_thread
);
535 is_elf64
= linux_pid_exe_is_elf_64_file (tid
, &machine
);
538 return tdesc_aarch64
;
540 return tdesc_arm_with_neon
;
543 /* Implementation of linux_target_ops method "arch_setup". */
546 aarch64_arch_setup (void)
548 current_process ()->tdesc
= aarch64_linux_read_description ();
550 aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread
));
553 static struct regset_info aarch64_regsets
[] =
555 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_PRSTATUS
,
556 sizeof (struct user_pt_regs
), GENERAL_REGS
,
557 aarch64_fill_gregset
, aarch64_store_gregset
},
558 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_FPREGSET
,
559 sizeof (struct user_fpsimd_state
), FP_REGS
,
560 aarch64_fill_fpregset
, aarch64_store_fpregset
562 { 0, 0, 0, -1, -1, NULL
, NULL
}
565 static struct regsets_info aarch64_regsets_info
=
567 aarch64_regsets
, /* regsets */
569 NULL
, /* disabled_regsets */
572 static struct regs_info regs_info_aarch64
=
574 NULL
, /* regset_bitmap */
576 &aarch64_regsets_info
,
579 /* Implementation of linux_target_ops method "regs_info". */
581 static const struct regs_info
*
582 aarch64_regs_info (void)
584 if (is_64bit_tdesc ())
585 return ®s_info_aarch64
;
587 return ®s_info_aarch32
;
590 /* Implementation of linux_target_ops method "supports_tracepoints". */
593 aarch64_supports_tracepoints (void)
595 if (current_thread
== NULL
)
599 /* We don't support tracepoints on aarch32 now. */
600 return is_64bit_tdesc ();
604 /* Implementation of linux_target_ops method "supports_range_stepping". */
607 aarch64_supports_range_stepping (void)
612 struct linux_target_ops the_low_target
=
616 aarch64_cannot_fetch_register
,
617 aarch64_cannot_store_register
,
618 NULL
, /* fetch_register */
621 (const unsigned char *) &aarch64_breakpoint
,
622 aarch64_breakpoint_len
,
623 NULL
, /* breakpoint_reinsert_addr */
624 0, /* decr_pc_after_break */
625 aarch64_breakpoint_at
,
626 aarch64_supports_z_point_type
,
627 aarch64_insert_point
,
628 aarch64_remove_point
,
629 aarch64_stopped_by_watchpoint
,
630 aarch64_stopped_data_address
,
631 NULL
, /* collect_ptrace_register */
632 NULL
, /* supply_ptrace_register */
633 NULL
, /* siginfo_fixup */
634 aarch64_linux_new_process
,
635 aarch64_linux_new_thread
,
636 aarch64_linux_new_fork
,
637 aarch64_linux_prepare_to_resume
,
638 NULL
, /* process_qsupported */
639 aarch64_supports_tracepoints
,
640 NULL
, /* get_thread_area */
641 NULL
, /* install_fast_tracepoint_jump_pad */
643 NULL
, /* get_min_fast_tracepoint_insn_len */
644 aarch64_supports_range_stepping
,
648 initialize_low_arch (void)
650 init_registers_aarch64 ();
652 initialize_low_arch_aarch32 ();
654 initialize_regsets_info (&aarch64_regsets_info
);