X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Flinux-aarch64-low.c;h=ad0481714574cad49fadf6f30e49f419bd3c16c0;hb=f9d949fb7b85323e3f307884a4a3cef6ba52607b;hp=8d2221842071b4217413f2bd71cf17aa550cc716;hpb=6a69a054f7581d16d4f65f80c45b92176311e1ef;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbserver/linux-aarch64-low.c b/gdb/gdbserver/linux-aarch64-low.c index 8d22218420..ad04817145 100644 --- a/gdb/gdbserver/linux-aarch64-low.c +++ b/gdb/gdbserver/linux-aarch64-low.c @@ -1,7 +1,7 @@ /* GNU/Linux/AArch64 specific low level interface, for the remote server for GDB. - Copyright (C) 2009-2015 Free Software Foundation, Inc. + Copyright (C) 2009-2019 Free Software Foundation, Inc. Contributed by ARM Ltd. This file is part of GDB. @@ -28,6 +28,7 @@ #include "elf/common.h" #include "ax.h" #include "tracepoint.h" +#include "debug.h" #include #include @@ -38,27 +39,16 @@ #include #include "gdb_proc_service.h" - -/* Defined in auto-generated files. */ -void init_registers_aarch64 (void); -extern const struct target_desc *tdesc_aarch64; +#include "arch/aarch64.h" +#include "linux-aarch32-tdesc.h" +#include "linux-aarch64-tdesc.h" +#include "nat/aarch64-sve-linux-ptrace.h" +#include "tdesc.h" #ifdef HAVE_SYS_REG_H #include #endif -#define AARCH64_X_REGS_NUM 31 -#define AARCH64_V_REGS_NUM 32 -#define AARCH64_X0_REGNO 0 -#define AARCH64_SP_REGNO 31 -#define AARCH64_PC_REGNO 32 -#define AARCH64_CPSR_REGNO 33 -#define AARCH64_V0_REGNO 34 -#define AARCH64_FPSR_REGNO (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM) -#define AARCH64_FPCR_REGNO (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM + 1) - -#define AARCH64_NUM_REGS (AARCH64_V0_REGNO + AARCH64_V_REGS_NUM + 2) - /* Per-process arch-specific data we want to keep. */ struct arch_process_info @@ -86,20 +76,14 @@ is_64bit_tdesc (void) return register_size (regcache->tdesc, 0) == 8; } -/* Implementation of linux_target_ops method "cannot_store_register". */ +/* Return true if the regcache contains the number of SVE registers. */ -static int -aarch64_cannot_store_register (int regno) +static bool +is_sve_tdesc (void) { - return regno >= AARCH64_NUM_REGS; -} - -/* Implementation of linux_target_ops method "cannot_fetch_register". */ + struct regcache *regcache = get_thread_regcache (current_thread, 0); -static int -aarch64_cannot_fetch_register (int regno) -{ - return regno >= AARCH64_NUM_REGS; + return regcache->tdesc->reg_defs.size () == AARCH64_SVE_NUM_REGS; } static void @@ -109,10 +93,10 @@ aarch64_fill_gregset (struct regcache *regcache, void *buf) int i; for (i = 0; i < AARCH64_X_REGS_NUM; i++) - collect_register (regcache, AARCH64_X0_REGNO + i, ®set->regs[i]); - collect_register (regcache, AARCH64_SP_REGNO, ®set->sp); - collect_register (regcache, AARCH64_PC_REGNO, ®set->pc); - collect_register (regcache, AARCH64_CPSR_REGNO, ®set->pstate); + collect_register (regcache, AARCH64_X0_REGNUM + i, ®set->regs[i]); + collect_register (regcache, AARCH64_SP_REGNUM, ®set->sp); + collect_register (regcache, AARCH64_PC_REGNUM, ®set->pc); + collect_register (regcache, AARCH64_CPSR_REGNUM, ®set->pstate); } static void @@ -122,39 +106,53 @@ aarch64_store_gregset (struct regcache *regcache, const void *buf) int i; for (i = 0; i < AARCH64_X_REGS_NUM; i++) - supply_register (regcache, AARCH64_X0_REGNO + i, ®set->regs[i]); - supply_register (regcache, AARCH64_SP_REGNO, ®set->sp); - supply_register (regcache, AARCH64_PC_REGNO, ®set->pc); - supply_register (regcache, AARCH64_CPSR_REGNO, ®set->pstate); + supply_register (regcache, AARCH64_X0_REGNUM + i, ®set->regs[i]); + supply_register (regcache, AARCH64_SP_REGNUM, ®set->sp); + supply_register (regcache, AARCH64_PC_REGNUM, ®set->pc); + supply_register (regcache, AARCH64_CPSR_REGNUM, ®set->pstate); } static void aarch64_fill_fpregset (struct regcache *regcache, void *buf) { - struct user_fpsimd_state *regset = buf; + struct user_fpsimd_state *regset = (struct user_fpsimd_state *) buf; int i; for (i = 0; i < AARCH64_V_REGS_NUM; i++) - collect_register (regcache, AARCH64_V0_REGNO + i, ®set->vregs[i]); - collect_register (regcache, AARCH64_FPSR_REGNO, ®set->fpsr); - collect_register (regcache, AARCH64_FPCR_REGNO, ®set->fpcr); + collect_register (regcache, AARCH64_V0_REGNUM + i, ®set->vregs[i]); + collect_register (regcache, AARCH64_FPSR_REGNUM, ®set->fpsr); + collect_register (regcache, AARCH64_FPCR_REGNUM, ®set->fpcr); } static void aarch64_store_fpregset (struct regcache *regcache, const void *buf) { - const struct user_fpsimd_state *regset = buf; + const struct user_fpsimd_state *regset + = (const struct user_fpsimd_state *) buf; int i; for (i = 0; i < AARCH64_V_REGS_NUM; i++) - supply_register (regcache, AARCH64_V0_REGNO + i, ®set->vregs[i]); - supply_register (regcache, AARCH64_FPSR_REGNO, ®set->fpsr); - supply_register (regcache, AARCH64_FPCR_REGNO, ®set->fpcr); + supply_register (regcache, AARCH64_V0_REGNUM + i, ®set->vregs[i]); + supply_register (regcache, AARCH64_FPSR_REGNUM, ®set->fpsr); + supply_register (regcache, AARCH64_FPCR_REGNUM, ®set->fpcr); } -/* Enable miscellaneous debugging output. The name is historical - it - was originally used to debug LinuxThreads support. */ -extern int debug_threads; +/* Store the pauth registers to regcache. */ + +static void +aarch64_store_pauthregset (struct regcache *regcache, const void *buf) +{ + uint64_t *pauth_regset = (uint64_t *) buf; + int pauth_base = find_regno (regcache->tdesc, "pauth_dmask"); + + if (pauth_base == 0) + return; + + supply_register (regcache, AARCH64_PAUTH_DMASK_REGNUM (pauth_base), + &pauth_regset[0]); + supply_register (regcache, AARCH64_PAUTH_CMASK_REGNUM (pauth_base), + &pauth_regset[1]); +} /* Implementation of linux_target_ops method "get_pc". */ @@ -162,23 +160,9 @@ static CORE_ADDR aarch64_get_pc (struct regcache *regcache) { if (register_size (regcache->tdesc, 0) == 8) - { - unsigned long pc; - - collect_register_by_name (regcache, "pc", &pc); - if (debug_threads) - debug_printf ("stop pc is %08lx\n", pc); - return pc; - } + return linux_get_pc_64bit (regcache); else - { - unsigned int pc; - - collect_register_by_name (regcache, "pc", &pc); - if (debug_threads) - debug_printf ("stop pc is %04x\n", pc); - return pc; - } + return linux_get_pc_32bit (regcache); } /* Implementation of linux_target_ops method "set_pc". */ @@ -187,15 +171,9 @@ static void aarch64_set_pc (struct regcache *regcache, CORE_ADDR pc) { if (register_size (regcache->tdesc, 0) == 8) - { - unsigned long newpc = pc; - supply_register_by_name (regcache, "pc", &newpc); - } + linux_set_pc_64bit (regcache, pc); else - { - unsigned int newpc = pc; - supply_register_by_name (regcache, "pc", &newpc); - } + linux_set_pc_32bit (regcache, pc); } #define aarch64_breakpoint_len 4 @@ -210,14 +188,19 @@ static const gdb_byte aarch64_breakpoint[] = {0x00, 0x00, 0x20, 0xd4}; static int aarch64_breakpoint_at (CORE_ADDR where) { - gdb_byte insn[aarch64_breakpoint_len]; + if (is_64bit_tdesc ()) + { + gdb_byte insn[aarch64_breakpoint_len]; - (*the_target->read_memory) (where, (unsigned char *) &insn, - aarch64_breakpoint_len); - if (memcmp (insn, aarch64_breakpoint, aarch64_breakpoint_len) == 0) - return 1; + (*the_target->read_memory) (where, (unsigned char *) &insn, + aarch64_breakpoint_len); + if (memcmp (insn, aarch64_breakpoint, aarch64_breakpoint_len) == 0) + return 1; - return 0; + return 0; + } + else + return arm_breakpoint_at (where); } static void @@ -259,22 +242,6 @@ aarch64_supports_z_point_type (char z_type) switch (z_type) { case Z_PACKET_SW_BP: - { - if (!extended_protocol && is_64bit_tdesc ()) - { - /* Only enable Z0 packet in non-multi-arch debugging. If - extended protocol is used, don't enable Z0 packet because - GDBserver may attach to 32-bit process. */ - return 1; - } - else - { - /* Disable Z0 packet so that GDBserver doesn't have to handle - different breakpoint instructions (aarch64, arm, thumb etc) - in multi-arch debugging. */ - return 0; - } - } case Z_PACKET_HW_BP: case Z_PACKET_WRITE_WP: case Z_PACKET_READ_WP: @@ -404,14 +371,39 @@ aarch64_stopped_data_address (void) state = aarch64_get_debug_reg_state (pid_of (current_thread)); for (i = aarch64_num_wp_regs - 1; i >= 0; --i) { + const unsigned int offset + = aarch64_watchpoint_offset (state->dr_ctrl_wp[i]); const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]); const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr; - const CORE_ADDR addr_watch = state->dr_addr_wp[i]; + const CORE_ADDR addr_watch = state->dr_addr_wp[i] + offset; + const CORE_ADDR addr_watch_aligned = align_down (state->dr_addr_wp[i], 8); + const CORE_ADDR addr_orig = state->dr_addr_orig_wp[i]; + if (state->dr_ref_count_wp[i] && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i]) - && addr_trap >= addr_watch + && addr_trap >= addr_watch_aligned && addr_trap < addr_watch + len) - return addr_trap; + { + /* ADDR_TRAP reports the first address of the memory range + accessed by the CPU, regardless of what was the memory + range watched. Thus, a large CPU access that straddles + the ADDR_WATCH..ADDR_WATCH+LEN range may result in an + ADDR_TRAP that is lower than the + ADDR_WATCH..ADDR_WATCH+LEN range. E.g.: + + addr: | 4 | 5 | 6 | 7 | 8 | + |---- range watched ----| + |----------- range accessed ------------| + + In this case, ADDR_TRAP will be 4. + + To match a watchpoint known to GDB core, we must never + report *ADDR_P outside of any ADDR_WATCH..ADDR_WATCH+LEN + range. ADDR_WATCH <= ADDR_TRAP < ADDR_ORIG is a false + positive on kernels older than 4.10. See PR + external/20207. */ + return addr_orig; + } } return (CORE_ADDR) 0; @@ -431,7 +423,7 @@ aarch64_stopped_by_watchpoint (void) /* Fetch the thread-local storage pointer for libthread_db. */ ps_err_e -ps_get_thread_area (const struct ps_prochandle *ph, +ps_get_thread_area (struct ps_prochandle *ph, lwpid_t lwpid, int idx, void **base) { return aarch64_ps_get_thread_area (ph, lwpid, idx, base, @@ -441,7 +433,7 @@ ps_get_thread_area (const struct ps_prochandle *ph, /* Implementation of linux_target_ops method "siginfo_fixup". */ static int -aarch64_linux_siginfo_fixup (siginfo_t *native, void *inf, int direction) +aarch64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction) { /* Is the inferior 32-bit? If so, then fixup the siginfo object. */ if (!is_64bit_tdesc ()) @@ -459,7 +451,7 @@ aarch64_linux_siginfo_fixup (siginfo_t *native, void *inf, int direction) return 0; } -/* Implementation of linux_target_ops method "linux_new_process". */ +/* Implementation of linux_target_ops method "new_process". */ static struct arch_process_info * aarch64_linux_new_process (void) @@ -471,6 +463,14 @@ aarch64_linux_new_process (void) return info; } +/* Implementation of linux_target_ops method "delete_process". */ + +static void +aarch64_linux_delete_process (struct arch_process_info *info) +{ + xfree (info); +} + /* Implementation of linux_target_ops method "linux_new_fork". */ static void @@ -500,11 +500,13 @@ aarch64_linux_new_fork (struct process_info *parent, *child->priv->arch_private = *parent->priv->arch_private; } -/* Return the right target description according to the ELF file of - current thread. */ +/* Matches HWCAP_PACA in kernel header arch/arm64/include/uapi/asm/hwcap.h. */ +#define AARCH64_HWCAP_PACA (1 << 30) -static const struct target_desc * -aarch64_linux_read_description (void) +/* Implementation of linux_target_ops method "arch_setup". */ + +static void +aarch64_arch_setup (void) { unsigned int machine; int is_elf64; @@ -515,19 +517,33 @@ aarch64_linux_read_description (void) is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine); if (is_elf64) - return tdesc_aarch64; + { + uint64_t vq = aarch64_sve_get_vq (tid); + unsigned long hwcap = linux_get_hwcap (8); + bool pauth_p = hwcap & AARCH64_HWCAP_PACA; + + current_process ()->tdesc = aarch64_linux_read_description (vq, pauth_p); + } else - return tdesc_arm_with_neon; + current_process ()->tdesc = aarch32_linux_read_description (); + + aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread)); } -/* Implementation of linux_target_ops method "arch_setup". */ +/* Wrapper for aarch64_sve_regs_copy_to_reg_buf. */ static void -aarch64_arch_setup (void) +aarch64_sve_regs_copy_to_regcache (struct regcache *regcache, const void *buf) { - current_process ()->tdesc = aarch64_linux_read_description (); + return aarch64_sve_regs_copy_to_reg_buf (regcache, buf); +} - aarch64_linux_get_debug_reg_capacity (lwpid_of (current_thread)); +/* Wrapper for aarch64_sve_regs_copy_from_reg_buf. */ + +static void +aarch64_sve_regs_copy_from_regcache (struct regcache *regcache, void *buf) +{ + return aarch64_sve_regs_copy_from_reg_buf (regcache, buf); } static struct regset_info aarch64_regsets[] = @@ -539,6 +555,9 @@ static struct regset_info aarch64_regsets[] = sizeof (struct user_fpsimd_state), FP_REGS, aarch64_fill_fpregset, aarch64_store_fpregset }, + { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_ARM_PAC_MASK, + AARCH64_PAUTH_REGS_SIZE, OPTIONAL_REGS, + NULL, aarch64_store_pauthregset }, NULL_REGSET }; @@ -556,15 +575,47 @@ static struct regs_info regs_info_aarch64 = &aarch64_regsets_info, }; +static struct regset_info aarch64_sve_regsets[] = +{ + { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS, + sizeof (struct user_pt_regs), GENERAL_REGS, + aarch64_fill_gregset, aarch64_store_gregset }, + { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_ARM_SVE, + SVE_PT_SIZE (AARCH64_MAX_SVE_VQ, SVE_PT_REGS_SVE), EXTENDED_REGS, + aarch64_sve_regs_copy_from_regcache, aarch64_sve_regs_copy_to_regcache + }, + { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_ARM_PAC_MASK, + AARCH64_PAUTH_REGS_SIZE, OPTIONAL_REGS, + NULL, aarch64_store_pauthregset }, + NULL_REGSET +}; + +static struct regsets_info aarch64_sve_regsets_info = + { + aarch64_sve_regsets, /* regsets. */ + 0, /* num_regsets. */ + NULL, /* disabled_regsets. */ + }; + +static struct regs_info regs_info_aarch64_sve = + { + NULL, /* regset_bitmap. */ + NULL, /* usrregs. */ + &aarch64_sve_regsets_info, + }; + /* Implementation of linux_target_ops method "regs_info". */ static const struct regs_info * aarch64_regs_info (void) { - if (is_64bit_tdesc ()) - return ®s_info_aarch64; - else + if (!is_64bit_tdesc ()) return ®s_info_aarch32; + + if (is_sve_tdesc ()) + return ®s_info_aarch64_sve; + + return ®s_info_aarch64; } /* Implementation of linux_target_ops method "supports_tracepoints". */ @@ -600,6 +651,24 @@ aarch64_get_thread_area (int lwpid, CORE_ADDR *addrp) return 0; } +/* Implementation of linux_target_ops method "get_syscall_trapinfo". */ + +static void +aarch64_get_syscall_trapinfo (struct regcache *regcache, int *sysno) +{ + int use_64bit = register_size (regcache->tdesc, 0) == 8; + + if (use_64bit) + { + long l_sysno; + + collect_register_by_name (regcache, "x8", &l_sysno); + *sysno = (int) l_sysno; + } + else + collect_register_by_name (regcache, "r7", sysno); +} + /* List of condition codes that we need. */ enum aarch64_condition_codes @@ -613,17 +682,20 @@ enum aarch64_condition_codes LE = 0xd, }; +enum aarch64_operand_type +{ + OPERAND_IMMEDIATE, + OPERAND_REGISTER, +}; + /* Representation of an operand. At this time, it only supports register and immediate types. */ struct aarch64_operand { /* Type of the operand. */ - enum - { - OPERAND_IMMEDIATE, - OPERAND_REGISTER, - } type; + enum aarch64_operand_type type; + /* Value of the operand according to the type. */ union { @@ -1025,7 +1097,7 @@ emit_stlr (uint32_t *buf, struct aarch64_register rt, /* Helper function for data processing instructions with register sources. */ static int -emit_data_processing_reg (uint32_t *buf, enum aarch64_opcodes opcode, +emit_data_processing_reg (uint32_t *buf, uint32_t opcode, struct aarch64_register rd, struct aarch64_register rn, struct aarch64_register rm) @@ -1545,17 +1617,17 @@ append_insns (CORE_ADDR *to, size_t len, const uint32_t *buf) { size_t byte_len = len * sizeof (uint32_t); #if (__BYTE_ORDER == __BIG_ENDIAN) - uint32_t *le_buf = xmalloc (byte_len); + uint32_t *le_buf = (uint32_t *) xmalloc (byte_len); size_t i; for (i = 0; i < len; i++) le_buf[i] = htole32 (buf[i]); - write_inferior_memory (*to, (const unsigned char *) le_buf, byte_len); + target_write_memory (*to, (const unsigned char *) le_buf, byte_len); xfree (le_buf); #else - write_inferior_memory (*to, (const unsigned char *) buf, byte_len); + target_write_memory (*to, (const unsigned char *) buf, byte_len); #endif *to += byte_len; @@ -1584,7 +1656,7 @@ aarch64_ftrace_insn_reloc_b (const int is_bl, const int32_t offset, { struct aarch64_insn_relocation_data *insn_reloc = (struct aarch64_insn_relocation_data *) data; - int32_t new_offset + int64_t new_offset = insn_reloc->base.insn_addr - insn_reloc->new_addr + offset; if (can_encode_int32 (new_offset, 28)) @@ -1599,7 +1671,7 @@ aarch64_ftrace_insn_reloc_b_cond (const unsigned cond, const int32_t offset, { struct aarch64_insn_relocation_data *insn_reloc = (struct aarch64_insn_relocation_data *) data; - int32_t new_offset + int64_t new_offset = insn_reloc->base.insn_addr - insn_reloc->new_addr + offset; if (can_encode_int32 (new_offset, 21)) @@ -1636,7 +1708,7 @@ aarch64_ftrace_insn_reloc_cb (const int32_t offset, const int is_cbnz, { struct aarch64_insn_relocation_data *insn_reloc = (struct aarch64_insn_relocation_data *) data; - int32_t new_offset + int64_t new_offset = insn_reloc->base.insn_addr - insn_reloc->new_addr + offset; if (can_encode_int32 (new_offset, 21)) @@ -1673,7 +1745,7 @@ aarch64_ftrace_insn_reloc_tb (const int32_t offset, int is_tbnz, { struct aarch64_insn_relocation_data *insn_reloc = (struct aarch64_insn_relocation_data *) data; - int32_t new_offset + int64_t new_offset = insn_reloc->base.insn_addr - insn_reloc->new_addr + offset; if (can_encode_int32 (new_offset, 16)) @@ -1809,7 +1881,7 @@ aarch64_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, { uint32_t buf[256]; uint32_t *p = buf; - int32_t offset; + int64_t offset; int i; uint32_t insn; CORE_ADDR buildaddr = *jump_entry; @@ -2146,7 +2218,7 @@ aarch64_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, { sprintf (err, "E.Jump back from jump pad too far from tracepoint " - "(offset 0x%" PRIx32 " cannot be encoded in 28 bits).", + "(offset 0x%" PRIx64 " cannot be encoded in 28 bits).", offset); return 1; } @@ -2160,7 +2232,7 @@ aarch64_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, { sprintf (err, "E.Jump pad too far from tracepoint " - "(offset 0x%" PRIx32 " cannot be encoded in 28 bits).", + "(offset 0x%" PRIx64 " cannot be encoded in 28 bits).", offset); return 1; } @@ -2285,7 +2357,7 @@ aarch64_emit_add (void) uint32_t *p = buf; p += emit_pop (p, x1); - p += emit_add (p, x0, x0, register_operand (x1)); + p += emit_add (p, x0, x1, register_operand (x0)); emit_ops_insns (buf, p - buf); } @@ -2299,7 +2371,7 @@ aarch64_emit_sub (void) uint32_t *p = buf; p += emit_pop (p, x1); - p += emit_sub (p, x0, x0, register_operand (x1)); + p += emit_sub (p, x0, x1, register_operand (x0)); emit_ops_insns (buf, p - buf); } @@ -2936,22 +3008,58 @@ aarch64_supports_range_stepping (void) static const gdb_byte * aarch64_sw_breakpoint_from_kind (int kind, int *size) { - *size = aarch64_breakpoint_len; - return aarch64_breakpoint; + if (is_64bit_tdesc ()) + { + *size = aarch64_breakpoint_len; + return aarch64_breakpoint; + } + else + return arm_sw_breakpoint_from_kind (kind, size); +} + +/* Implementation of linux_target_ops method "breakpoint_kind_from_pc". */ + +static int +aarch64_breakpoint_kind_from_pc (CORE_ADDR *pcptr) +{ + if (is_64bit_tdesc ()) + return aarch64_breakpoint_len; + else + return arm_breakpoint_kind_from_pc (pcptr); +} + +/* Implementation of the linux_target_ops method + "breakpoint_kind_from_current_state". */ + +static int +aarch64_breakpoint_kind_from_current_state (CORE_ADDR *pcptr) +{ + if (is_64bit_tdesc ()) + return aarch64_breakpoint_len; + else + return arm_breakpoint_kind_from_current_state (pcptr); +} + +/* Support for hardware single step. */ + +static int +aarch64_supports_hardware_single_step (void) +{ + return 1; } struct linux_target_ops the_low_target = { aarch64_arch_setup, aarch64_regs_info, - aarch64_cannot_fetch_register, - aarch64_cannot_store_register, + NULL, /* cannot_fetch_register */ + NULL, /* cannot_store_register */ NULL, /* fetch_register */ aarch64_get_pc, aarch64_set_pc, - NULL, /* breakpoint_kind_from_pc */ + aarch64_breakpoint_kind_from_pc, aarch64_sw_breakpoint_from_kind, - NULL, /* breakpoint_reinsert_addr */ + NULL, /* get_next_pcs */ 0, /* decr_pc_after_break */ aarch64_breakpoint_at, aarch64_supports_z_point_type, @@ -2963,7 +3071,9 @@ struct linux_target_ops the_low_target = NULL, /* supply_ptrace_register */ aarch64_linux_siginfo_fixup, aarch64_linux_new_process, + aarch64_linux_delete_process, aarch64_linux_new_thread, + aarch64_linux_delete_thread, aarch64_linux_new_fork, aarch64_linux_prepare_to_resume, NULL, /* process_qsupported */ @@ -2973,14 +3083,16 @@ struct linux_target_ops the_low_target = aarch64_emit_ops, aarch64_get_min_fast_tracepoint_insn_len, aarch64_supports_range_stepping, + aarch64_breakpoint_kind_from_current_state, + aarch64_supports_hardware_single_step, + aarch64_get_syscall_trapinfo, }; void initialize_low_arch (void) { - init_registers_aarch64 (); - initialize_low_arch_aarch32 (); initialize_regsets_info (&aarch64_regsets_info); + initialize_regsets_info (&aarch64_sve_regsets_info); }