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 arch_lwp_info
*info
= lwp_arch_private_info (lwp
);
494 if (DR_HAS_CHANGED (info
->dr_changed_bp
)
495 || DR_HAS_CHANGED (info
->dr_changed_wp
))
497 ptid_t ptid
= ptid_of_lwp (lwp
);
498 int tid
= ptid_get_lwp (ptid
);
499 struct aarch64_debug_reg_state
*state
500 = aarch64_get_debug_reg_state (ptid_get_pid (ptid
));
503 fprintf (stderr
, "prepare_to_resume thread %d\n", tid
);
506 if (DR_HAS_CHANGED (info
->dr_changed_wp
))
508 aarch64_linux_set_debug_regs (state
, tid
, 1);
509 DR_CLEAR_CHANGED (info
->dr_changed_wp
);
513 if (DR_HAS_CHANGED (info
->dr_changed_bp
))
515 aarch64_linux_set_debug_regs (state
, tid
, 0);
516 DR_CLEAR_CHANGED (info
->dr_changed_bp
);
521 /* Return the right target description according to the ELF file of
524 static const struct target_desc
*
525 aarch64_linux_read_description (void)
527 unsigned int machine
;
531 tid
= lwpid_of (current_thread
);
533 is_elf64
= linux_pid_exe_is_elf_64_file (tid
, &machine
);
536 return tdesc_aarch64
;
538 return tdesc_arm_with_neon
;
541 /* Implementation of linux_target_ops method "arch_setup". */
544 aarch64_arch_setup (void)
546 current_process ()->tdesc
= aarch64_linux_read_description ();
548 aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread
));
551 static struct regset_info aarch64_regsets
[] =
553 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_PRSTATUS
,
554 sizeof (struct user_pt_regs
), GENERAL_REGS
,
555 aarch64_fill_gregset
, aarch64_store_gregset
},
556 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_FPREGSET
,
557 sizeof (struct user_fpsimd_state
), FP_REGS
,
558 aarch64_fill_fpregset
, aarch64_store_fpregset
560 { 0, 0, 0, -1, -1, NULL
, NULL
}
563 static struct regsets_info aarch64_regsets_info
=
565 aarch64_regsets
, /* regsets */
567 NULL
, /* disabled_regsets */
570 static struct regs_info regs_info_aarch64
=
572 NULL
, /* regset_bitmap */
574 &aarch64_regsets_info
,
577 /* Implementation of linux_target_ops method "regs_info". */
579 static const struct regs_info
*
580 aarch64_regs_info (void)
582 if (is_64bit_tdesc ())
583 return ®s_info_aarch64
;
585 return ®s_info_aarch32
;
588 /* Implementation of linux_target_ops method "supports_tracepoints". */
591 aarch64_supports_tracepoints (void)
593 if (current_thread
== NULL
)
597 /* We don't support tracepoints on aarch32 now. */
598 return is_64bit_tdesc ();
602 /* Implementation of linux_target_ops method "supports_range_stepping". */
605 aarch64_supports_range_stepping (void)
610 struct linux_target_ops the_low_target
=
614 aarch64_cannot_fetch_register
,
615 aarch64_cannot_store_register
,
616 NULL
, /* fetch_register */
619 (const unsigned char *) &aarch64_breakpoint
,
620 aarch64_breakpoint_len
,
621 NULL
, /* breakpoint_reinsert_addr */
622 0, /* decr_pc_after_break */
623 aarch64_breakpoint_at
,
624 aarch64_supports_z_point_type
,
625 aarch64_insert_point
,
626 aarch64_remove_point
,
627 aarch64_stopped_by_watchpoint
,
628 aarch64_stopped_data_address
,
629 NULL
, /* collect_ptrace_register */
630 NULL
, /* supply_ptrace_register */
631 NULL
, /* siginfo_fixup */
632 aarch64_linux_new_process
,
633 aarch64_linux_new_thread
,
634 aarch64_linux_new_fork
,
635 aarch64_linux_prepare_to_resume
,
636 NULL
, /* process_qsupported */
637 aarch64_supports_tracepoints
,
638 NULL
, /* get_thread_area */
639 NULL
, /* install_fast_tracepoint_jump_pad */
641 NULL
, /* get_min_fast_tracepoint_insn_len */
642 aarch64_supports_range_stepping
,
646 initialize_low_arch (void)
648 init_registers_aarch64 ();
650 initialize_low_arch_aarch32 ();
652 initialize_regsets_info (&aarch64_regsets_info
);