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.h"
25 #include "nat/aarch64-linux-hw-point.h"
26 #include "linux-aarch32-low.h"
27 #include "elf/common.h"
31 #include "nat/gdb_ptrace.h"
32 #include <asm/ptrace.h>
35 #include "gdb_proc_service.h"
37 /* Defined in auto-generated files. */
38 void init_registers_aarch64 (void);
39 extern const struct target_desc
*tdesc_aarch64
;
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)
55 #define AARCH64_NUM_REGS (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM + 2)
57 /* Per-process arch-specific data we want to keep. */
59 struct arch_process_info
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.
71 struct aarch64_debug_reg_state debug_reg_state
;
74 /* Return true if the size of register 0 is 8 byte. */
79 struct regcache
*regcache
= get_thread_regcache (current_thread
, 0);
81 return register_size (regcache
->tdesc
, 0) == 8;
84 /* Implementation of linux_target_ops method "cannot_store_register". */
87 aarch64_cannot_store_register (int regno
)
89 return regno
>= AARCH64_NUM_REGS
;
92 /* Implementation of linux_target_ops method "cannot_fetch_register". */
95 aarch64_cannot_fetch_register (int regno
)
97 return regno
>= AARCH64_NUM_REGS
;
101 aarch64_fill_gregset (struct regcache
*regcache
, void *buf
)
103 struct user_pt_regs
*regset
= buf
;
106 for (i
= 0; i
< AARCH64_X_REGS_NUM
; i
++)
107 collect_register (regcache
, AARCH64_X0_REGNO
+ i
, ®set
->regs
[i
]);
108 collect_register (regcache
, AARCH64_SP_REGNO
, ®set
->sp
);
109 collect_register (regcache
, AARCH64_PC_REGNO
, ®set
->pc
);
110 collect_register (regcache
, AARCH64_CPSR_REGNO
, ®set
->pstate
);
114 aarch64_store_gregset (struct regcache
*regcache
, const void *buf
)
116 const struct user_pt_regs
*regset
= buf
;
119 for (i
= 0; i
< AARCH64_X_REGS_NUM
; i
++)
120 supply_register (regcache
, AARCH64_X0_REGNO
+ i
, ®set
->regs
[i
]);
121 supply_register (regcache
, AARCH64_SP_REGNO
, ®set
->sp
);
122 supply_register (regcache
, AARCH64_PC_REGNO
, ®set
->pc
);
123 supply_register (regcache
, AARCH64_CPSR_REGNO
, ®set
->pstate
);
127 aarch64_fill_fpregset (struct regcache
*regcache
, void *buf
)
129 struct user_fpsimd_state
*regset
= buf
;
132 for (i
= 0; i
< AARCH64_V_REGS_NUM
; i
++)
133 collect_register (regcache
, AARCH64_V0_REGNO
+ i
, ®set
->vregs
[i
]);
134 collect_register (regcache
, AARCH64_FPSR_REGNO
, ®set
->fpsr
);
135 collect_register (regcache
, AARCH64_FPCR_REGNO
, ®set
->fpcr
);
139 aarch64_store_fpregset (struct regcache
*regcache
, const void *buf
)
141 const struct user_fpsimd_state
*regset
= buf
;
144 for (i
= 0; i
< AARCH64_V_REGS_NUM
; i
++)
145 supply_register (regcache
, AARCH64_V0_REGNO
+ i
, ®set
->vregs
[i
]);
146 supply_register (regcache
, AARCH64_FPSR_REGNO
, ®set
->fpsr
);
147 supply_register (regcache
, AARCH64_FPCR_REGNO
, ®set
->fpcr
);
150 /* Enable miscellaneous debugging output. The name is historical - it
151 was originally used to debug LinuxThreads support. */
152 extern int debug_threads
;
154 /* Implementation of linux_target_ops method "get_pc". */
157 aarch64_get_pc (struct regcache
*regcache
)
159 if (register_size (regcache
->tdesc
, 0) == 8)
163 collect_register_by_name (regcache
, "pc", &pc
);
165 debug_printf ("stop pc is %08lx\n", pc
);
172 collect_register_by_name (regcache
, "pc", &pc
);
174 debug_printf ("stop pc is %04x\n", pc
);
179 /* Implementation of linux_target_ops method "set_pc". */
182 aarch64_set_pc (struct regcache
*regcache
, CORE_ADDR pc
)
184 if (register_size (regcache
->tdesc
, 0) == 8)
186 unsigned long newpc
= pc
;
187 supply_register_by_name (regcache
, "pc", &newpc
);
191 unsigned int newpc
= pc
;
192 supply_register_by_name (regcache
, "pc", &newpc
);
196 #define aarch64_breakpoint_len 4
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};
203 /* Implementation of linux_target_ops method "breakpoint_at". */
206 aarch64_breakpoint_at (CORE_ADDR where
)
208 gdb_byte insn
[aarch64_breakpoint_len
];
210 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
,
211 aarch64_breakpoint_len
);
212 if (memcmp (insn
, aarch64_breakpoint
, aarch64_breakpoint_len
) == 0)
219 aarch64_init_debug_reg_state (struct aarch64_debug_reg_state
*state
)
223 for (i
= 0; i
< AARCH64_HBP_MAX_NUM
; ++i
)
225 state
->dr_addr_bp
[i
] = 0;
226 state
->dr_ctrl_bp
[i
] = 0;
227 state
->dr_ref_count_bp
[i
] = 0;
230 for (i
= 0; i
< AARCH64_HWP_MAX_NUM
; ++i
)
232 state
->dr_addr_wp
[i
] = 0;
233 state
->dr_ctrl_wp
[i
] = 0;
234 state
->dr_ref_count_wp
[i
] = 0;
238 /* Return the pointer to the debug register state structure in the
239 current process' arch-specific data area. */
241 struct aarch64_debug_reg_state
*
242 aarch64_get_debug_reg_state (pid_t pid
)
244 struct process_info
*proc
= find_process_pid (pid
);
246 return &proc
->priv
->arch_private
->debug_reg_state
;
249 /* Implementation of linux_target_ops method "supports_z_point_type". */
252 aarch64_supports_z_point_type (char z_type
)
258 if (!extended_protocol
&& is_64bit_tdesc ())
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. */
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. */
274 case Z_PACKET_WRITE_WP
:
275 case Z_PACKET_READ_WP
:
276 case Z_PACKET_ACCESS_WP
:
283 /* Implementation of linux_target_ops method "insert_point".
285 It actually only records the info of the to-be-inserted bp/wp;
286 the actual insertion will happen when threads are resumed. */
289 aarch64_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
290 int len
, struct raw_breakpoint
*bp
)
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
));
298 fprintf (stderr
, "insert_point on entry (addr=0x%08lx, len=%d)\n",
299 (unsigned long) addr
, len
);
301 /* Determine the type from the raw breakpoint type. */
302 targ_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
304 if (targ_type
!= hw_execute
)
306 if (aarch64_linux_region_ok_for_watchpoint (addr
, len
))
307 ret
= aarch64_handle_watchpoint (targ_type
, addr
, len
,
308 1 /* is_insert */, state
);
314 aarch64_handle_breakpoint (targ_type
, addr
, len
, 1 /* is_insert */,
318 aarch64_show_debug_reg_state (state
, "insert_point", addr
, len
,
324 /* Implementation of linux_target_ops method "remove_point".
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. */
330 aarch64_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
331 int len
, struct raw_breakpoint
*bp
)
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
));
339 fprintf (stderr
, "remove_point on entry (addr=0x%08lx, len=%d)\n",
340 (unsigned long) addr
, len
);
342 /* Determine the type from the raw breakpoint type. */
343 targ_type
= raw_bkpt_type_to_target_hw_bp_type (type
);
345 /* Set up state pointers. */
346 if (targ_type
!= hw_execute
)
348 aarch64_handle_watchpoint (targ_type
, addr
, len
, 0 /* is_insert */,
352 aarch64_handle_breakpoint (targ_type
, addr
, len
, 0 /* is_insert */,
356 aarch64_show_debug_reg_state (state
, "remove_point", addr
, len
,
362 /* Implementation of linux_target_ops method "stopped_data_address". */
365 aarch64_stopped_data_address (void)
369 struct aarch64_debug_reg_state
*state
;
371 pid
= lwpid_of (current_thread
);
373 /* Get the siginfo. */
374 if (ptrace (PTRACE_GETSIGINFO
, pid
, NULL
, &siginfo
) != 0)
375 return (CORE_ADDR
) 0;
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;
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
)
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
)
396 return (CORE_ADDR
) 0;
399 /* Implementation of linux_target_ops method "stopped_by_watchpoint". */
402 aarch64_stopped_by_watchpoint (void)
404 if (aarch64_stopped_data_address () != 0)
410 /* Fetch the thread-local storage pointer for libthread_db. */
413 ps_get_thread_area (const struct ps_prochandle
*ph
,
414 lwpid_t lwpid
, int idx
, void **base
)
419 iovec
.iov_base
= ®
;
420 iovec
.iov_len
= sizeof (reg
);
422 if (ptrace (PTRACE_GETREGSET
, lwpid
, NT_ARM_TLS
, &iovec
) != 0)
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
);
433 /* Implementation of linux_target_ops method "siginfo_fixup". */
436 aarch64_linux_siginfo_fixup (siginfo_t
*native
, void *inf
, int direction
)
438 /* Is the inferior 32-bit? If so, then fixup the siginfo object. */
439 if (!is_64bit_tdesc ())
442 aarch64_compat_siginfo_from_siginfo ((struct compat_siginfo
*) inf
,
445 aarch64_siginfo_from_compat_siginfo (native
,
446 (struct compat_siginfo
*) inf
);
454 /* Implementation of linux_target_ops method "linux_new_process". */
456 static struct arch_process_info
*
457 aarch64_linux_new_process (void)
459 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
461 aarch64_init_debug_reg_state (&info
->debug_reg_state
);
466 /* Implementation of linux_target_ops method "linux_new_fork". */
469 aarch64_linux_new_fork (struct process_info
*parent
,
470 struct process_info
*child
)
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
);
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.
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. */
492 *child
->priv
->arch_private
= *parent
->priv
->arch_private
;
495 /* Return the right target description according to the ELF file of
498 static const struct target_desc
*
499 aarch64_linux_read_description (void)
501 unsigned int machine
;
505 tid
= lwpid_of (current_thread
);
507 is_elf64
= linux_pid_exe_is_elf_64_file (tid
, &machine
);
510 return tdesc_aarch64
;
512 return tdesc_arm_with_neon
;
515 /* Implementation of linux_target_ops method "arch_setup". */
518 aarch64_arch_setup (void)
520 current_process ()->tdesc
= aarch64_linux_read_description ();
522 aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread
));
525 static struct regset_info aarch64_regsets
[] =
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
534 { 0, 0, 0, -1, -1, NULL
, NULL
}
537 static struct regsets_info aarch64_regsets_info
=
539 aarch64_regsets
, /* regsets */
541 NULL
, /* disabled_regsets */
544 static struct regs_info regs_info_aarch64
=
546 NULL
, /* regset_bitmap */
548 &aarch64_regsets_info
,
551 /* Implementation of linux_target_ops method "regs_info". */
553 static const struct regs_info
*
554 aarch64_regs_info (void)
556 if (is_64bit_tdesc ())
557 return ®s_info_aarch64
;
559 return ®s_info_aarch32
;
562 /* Implementation of linux_target_ops method "supports_tracepoints". */
565 aarch64_supports_tracepoints (void)
567 if (current_thread
== NULL
)
571 /* We don't support tracepoints on aarch32 now. */
572 return is_64bit_tdesc ();
576 /* Implementation of linux_target_ops method "supports_range_stepping". */
579 aarch64_supports_range_stepping (void)
584 struct linux_target_ops the_low_target
=
588 aarch64_cannot_fetch_register
,
589 aarch64_cannot_store_register
,
590 NULL
, /* fetch_register */
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 */
615 NULL
, /* get_min_fast_tracepoint_insn_len */
616 aarch64_supports_range_stepping
,
620 initialize_low_arch (void)
622 init_registers_aarch64 ();
624 initialize_low_arch_aarch32 ();
626 initialize_regsets_info (&aarch64_regsets_info
);