X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Faarch64-linux-tdep.c;h=0d46acde5fad5c4804424602a407de9d8b8fc60d;hb=7bc02706c3e23b58e1a74ca47fada84fc68699c7;hp=57cb97358709575444b0c4fd4a4ae7117b94ce58;hpb=7571f7f297c8d8b4fb4657f84437b1d156957e16;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/aarch64-linux-tdep.c b/gdb/aarch64-linux-tdep.c index 57cb973587..0d46acde5f 100644 --- a/gdb/aarch64-linux-tdep.c +++ b/gdb/aarch64-linux-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for GNU/Linux AArch64. - Copyright (C) 2009-2015 Free Software Foundation, Inc. + Copyright (C) 2009-2018 Free Software Foundation, Inc. Contributed by ARM Ltd. This file is part of GDB. @@ -45,6 +45,8 @@ #include "record-full.h" #include "linux-record.h" +#include "auxv.h" +#include "elf/common.h" /* Signal frame handling. @@ -143,7 +145,6 @@ aarch64_linux_sigframe_init (const struct tramp_frame *self, struct trad_frame_cache *this_cache, CORE_ADDR func) { - struct gdbarch *gdbarch = get_frame_arch (this_frame); CORE_ADDR sp = get_frame_register_unsigned (this_frame, AARCH64_SP_REGNUM); CORE_ADDR sigcontext_addr = sp @@ -175,12 +176,12 @@ static const struct tramp_frame aarch64_linux_rt_sigframe = { /* movz x8, 0x8b (S=1,o=10,h=0,i=0x8b,r=8) Soo1 0010 1hhi iiii iiii iiii iiir rrrr */ - {0xd2801168, -1}, + {0xd2801168, ULONGEST_MAX}, /* svc 0x0 (o=0, l=1) 1101 0100 oooi iiii iiii iiii iii0 00ll */ - {0xd4000001, -1}, - {TRAMP_SENTINEL_INSN, -1} + {0xd4000001, ULONGEST_MAX}, + {TRAMP_SENTINEL_INSN, ULONGEST_MAX} }, aarch64_linux_sigframe_init }; @@ -218,6 +219,180 @@ const struct regset aarch64_linux_fpregset = regcache_supply_regset, regcache_collect_regset }; +/* The fields in an SVE header at the start of a SVE regset. */ + +#define SVE_HEADER_SIZE_LENGTH 4 +#define SVE_HEADER_MAX_SIZE_LENGTH 4 +#define SVE_HEADER_VL_LENGTH 2 +#define SVE_HEADER_MAX_VL_LENGTH 2 +#define SVE_HEADER_FLAGS_LENGTH 2 +#define SVE_HEADER_RESERVED_LENGTH 2 + +#define SVE_HEADER_SIZE_OFFSET 0 +#define SVE_HEADER_MAX_SIZE_OFFSET \ + (SVE_HEADER_SIZE_OFFSET + SVE_HEADER_SIZE_LENGTH) +#define SVE_HEADER_VL_OFFSET \ + (SVE_HEADER_MAX_SIZE_OFFSET + SVE_HEADER_MAX_SIZE_LENGTH) +#define SVE_HEADER_MAX_VL_OFFSET \ + (SVE_HEADER_VL_OFFSET + SVE_HEADER_VL_LENGTH) +#define SVE_HEADER_FLAGS_OFFSET \ + (SVE_HEADER_MAX_VL_OFFSET + SVE_HEADER_MAX_VL_LENGTH) +#define SVE_HEADER_RESERVED_OFFSET \ + (SVE_HEADER_FLAGS_OFFSET + SVE_HEADER_FLAGS_LENGTH) +#define SVE_HEADER_SIZE \ + (SVE_HEADER_RESERVED_OFFSET + SVE_HEADER_RESERVED_LENGTH) + +#define SVE_HEADER_FLAG_SVE 1 + +/* Get VQ value from SVE section in the core dump. */ + +static uint64_t +aarch64_linux_core_read_vq (struct gdbarch *gdbarch, bfd *abfd) +{ + gdb_byte header[SVE_HEADER_SIZE]; + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + asection *sve_section = bfd_get_section_by_name (abfd, ".reg-aarch-sve"); + + if (sve_section == nullptr) + { + /* No SVE state. */ + return 0; + } + + size_t size = bfd_section_size (abfd, sve_section); + + /* Check extended state size. */ + if (size < SVE_HEADER_SIZE) + { + warning (_("'.reg-aarch-sve' section in core file too small.")); + return 0; + } + + if (!bfd_get_section_contents (abfd, sve_section, header, 0, SVE_HEADER_SIZE)) + { + warning (_("Couldn't read sve header from " + "'.reg-aarch-sve' section in core file.")); + return 0; + } + + uint64_t vl = extract_unsigned_integer (header + SVE_HEADER_VL_OFFSET, + SVE_HEADER_VL_LENGTH, byte_order); + uint64_t vq = sve_vq_from_vl (vl); + + if (vq > AARCH64_MAX_SVE_VQ) + { + warning (_("SVE Vector length in core file not supported by this version" + " of GDB. (VQ=%s)"), pulongest (vq)); + return 0; + } + else if (vq == 0) + { + warning (_("SVE Vector length in core file is invalid. (VQ=%s"), + pulongest (vq)); + return 0; + } + + return vq; +} + +/* Supply register REGNUM from BUF to REGCACHE, using the register map + in REGSET. If REGNUM is -1, do this for all registers in REGSET. + If BUF is NULL, set the registers to "unavailable" status. */ + +static void +aarch64_linux_supply_sve_regset (const struct regset *regset, + struct regcache *regcache, + int regnum, const void *buf, size_t size) +{ + gdb_byte *header = (gdb_byte *) buf; + struct gdbarch *gdbarch = regcache->arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + + if (buf == nullptr) + return regcache->supply_regset (regset, regnum, nullptr, size); + gdb_assert (size > SVE_HEADER_SIZE); + + /* BUF contains an SVE header followed by a register dump of either the + passed in SVE regset or a NEON fpregset. */ + + /* Extract required fields from the header. */ + uint64_t vl = extract_unsigned_integer (header + SVE_HEADER_VL_OFFSET, + SVE_HEADER_VL_LENGTH, byte_order); + uint16_t flags = extract_unsigned_integer (header + SVE_HEADER_FLAGS_OFFSET, + SVE_HEADER_FLAGS_LENGTH, + byte_order); + + if (regnum == -1 || regnum == AARCH64_SVE_VG_REGNUM) + { + gdb_byte vg_target[8]; + store_integer ((gdb_byte *)&vg_target, sizeof (uint64_t), byte_order, + sve_vg_from_vl (vl)); + regcache->raw_supply (AARCH64_SVE_VG_REGNUM, &vg_target); + } + + if (flags & SVE_HEADER_FLAG_SVE) + { + /* Register dump is a SVE structure. */ + regcache->supply_regset (regset, regnum, + (gdb_byte *) buf + SVE_HEADER_SIZE, + size - SVE_HEADER_SIZE); + } + else + { + /* Register dump is a fpsimd structure. First clear the SVE + registers. */ + for (int i = 0; i < AARCH64_SVE_Z_REGS_NUM; i++) + regcache->raw_supply_zeroed (AARCH64_SVE_Z0_REGNUM + i); + for (int i = 0; i < AARCH64_SVE_P_REGS_NUM; i++) + regcache->raw_supply_zeroed (AARCH64_SVE_P0_REGNUM + i); + regcache->raw_supply_zeroed (AARCH64_SVE_FFR_REGNUM); + + /* Then supply the fpsimd registers. */ + regcache->supply_regset (&aarch64_linux_fpregset, regnum, + (gdb_byte *) buf + SVE_HEADER_SIZE, + size - SVE_HEADER_SIZE); + } +} + +/* Collect register REGNUM from REGCACHE to BUF, using the register + map in REGSET. If REGNUM is -1, do this for all registers in + REGSET. */ + +static void +aarch64_linux_collect_sve_regset (const struct regset *regset, + const struct regcache *regcache, + int regnum, void *buf, size_t size) +{ + gdb_byte *header = (gdb_byte *) buf; + struct gdbarch *gdbarch = regcache->arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + uint64_t vq = gdbarch_tdep (gdbarch)->vq; + + gdb_assert (buf != NULL); + gdb_assert (size > SVE_HEADER_SIZE); + + /* BUF starts with a SVE header prior to the register dump. */ + + store_unsigned_integer (header + SVE_HEADER_SIZE_OFFSET, + SVE_HEADER_SIZE_LENGTH, byte_order, size); + store_unsigned_integer (header + SVE_HEADER_MAX_SIZE_OFFSET, + SVE_HEADER_MAX_SIZE_LENGTH, byte_order, size); + store_unsigned_integer (header + SVE_HEADER_VL_OFFSET, SVE_HEADER_VL_LENGTH, + byte_order, sve_vl_from_vq (vq)); + store_unsigned_integer (header + SVE_HEADER_MAX_VL_OFFSET, + SVE_HEADER_MAX_VL_LENGTH, byte_order, + sve_vl_from_vq (vq)); + store_unsigned_integer (header + SVE_HEADER_FLAGS_OFFSET, + SVE_HEADER_FLAGS_LENGTH, byte_order, + SVE_HEADER_FLAG_SVE); + store_unsigned_integer (header + SVE_HEADER_RESERVED_OFFSET, + SVE_HEADER_RESERVED_LENGTH, byte_order, 0); + + /* The SVE register dump follows. */ + regcache->collect_regset (regset, regnum, (gdb_byte *) buf + SVE_HEADER_SIZE, + size - SVE_HEADER_SIZE); +} + /* Implement the "regset_from_core_section" gdbarch method. */ static void @@ -226,10 +401,53 @@ aarch64_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, void *cb_data, const struct regcache *regcache) { - cb (".reg", AARCH64_LINUX_SIZEOF_GREGSET, &aarch64_linux_gregset, - NULL, cb_data); - cb (".reg2", AARCH64_LINUX_SIZEOF_FPREGSET, &aarch64_linux_fpregset, - NULL, cb_data); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + cb (".reg", AARCH64_LINUX_SIZEOF_GREGSET, AARCH64_LINUX_SIZEOF_GREGSET, + &aarch64_linux_gregset, NULL, cb_data); + + if (tdep->has_sve ()) + { + /* Create this on the fly in order to handle vector register sizes. */ + const struct regcache_map_entry sve_regmap[] = + { + { 32, AARCH64_SVE_Z0_REGNUM, tdep->vq * 16 }, + { 16, AARCH64_SVE_P0_REGNUM, tdep->vq * 16 / 8 }, + { 1, AARCH64_SVE_FFR_REGNUM, 4 }, + { 1, AARCH64_FPSR_REGNUM, 4 }, + { 1, AARCH64_FPCR_REGNUM, 4 }, + { 0 } + }; + + const struct regset aarch64_linux_sve_regset = + { + sve_regmap, + aarch64_linux_supply_sve_regset, aarch64_linux_collect_sve_regset, + REGSET_VARIABLE_SIZE + }; + + cb (".reg-aarch-sve", + SVE_HEADER_SIZE + regcache_map_entry_size (aarch64_linux_fpregmap), + SVE_HEADER_SIZE + regcache_map_entry_size (sve_regmap), + &aarch64_linux_sve_regset, "SVE registers", cb_data); + } + else + cb (".reg2", AARCH64_LINUX_SIZEOF_FPREGSET, AARCH64_LINUX_SIZEOF_FPREGSET, + &aarch64_linux_fpregset, NULL, cb_data); +} + +/* Implement the "core_read_description" gdbarch method. */ + +static const struct target_desc * +aarch64_linux_core_read_description (struct gdbarch *gdbarch, + struct target_ops *target, bfd *abfd) +{ + CORE_ADDR aarch64_hwcap = 0; + + if (target_auxv_search (target, AT_HWCAP, &aarch64_hwcap) != 1) + return NULL; + + return aarch64_read_description (aarch64_linux_core_read_vq (gdbarch, abfd)); } /* Implementation of `gdbarch_stap_is_single_operand', as defined in @@ -290,7 +508,7 @@ aarch64_stap_parse_special_token (struct gdbarch *gdbarch, regname, p->saved_arg); ++tmp; - tmp = skip_spaces_const (tmp); + tmp = skip_spaces (tmp); /* Now we expect a number. It can begin with '#' or simply a digit. */ if (*tmp == '#') @@ -350,9 +568,9 @@ aarch64_stap_parse_special_token (struct gdbarch *gdbarch, static LONGEST aarch64_linux_get_syscall_number (struct gdbarch *gdbarch, - ptid_t ptid) + thread_info *thread) { - struct regcache *regs = get_thread_regcache (ptid); + struct regcache *regs = get_thread_regcache (thread); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); /* The content of register x8. */ @@ -361,7 +579,7 @@ aarch64_linux_get_syscall_number (struct gdbarch *gdbarch, LONGEST ret; /* Getting the system call number from the register x8. */ - regcache_cooked_read (regs, AARCH64_DWARF_X0 + 8, buf); + regs->cooked_read (AARCH64_DWARF_X0 + 8, buf); ret = extract_signed_integer (buf, X_REGISTER_SIZE, byte_order); @@ -409,12 +627,12 @@ enum aarch64_syscall { aarch64_sys_ioprio_set = 30, aarch64_sys_ioprio_get = 31, aarch64_sys_flock = 32, - aarch64_sys_mknod = 33, - aarch64_sys_mkdir = 34, - aarch64_sys_unlink = 35, - aarch64_sys_symlink = 36, - aarch64_sys_link = 37, - aarch64_sys_rename = 38, + aarch64_sys_mknodat = 33, + aarch64_sys_mkdirat = 34, + aarch64_sys_unlinkat = 35, + aarch64_sys_symlinkat = 36, + aarch64_sys_linkat = 37, + aarch64_sys_renameat = 38, aarch64_sys_umount2 = 39, aarch64_sys_mount = 40, aarch64_sys_pivot_root = 41, @@ -424,7 +642,7 @@ enum aarch64_syscall { aarch64_sys_truncate = 45, aarch64_sys_ftruncate = 46, aarch64_sys_fallocate = 47, - aarch64_sys_faccess = 48, + aarch64_sys_faccessat = 48, aarch64_sys_chdir = 49, aarch64_sys_fchdir = 50, aarch64_sys_chroot = 51, @@ -432,7 +650,7 @@ enum aarch64_syscall { aarch64_sys_fchmodat = 53, aarch64_sys_fchownat = 54, aarch64_sys_fchown = 55, - aarch64_sys_open = 56, + aarch64_sys_openat = 56, aarch64_sys_close = 57, aarch64_sys_vhangup = 58, aarch64_sys_pipe2 = 59, @@ -454,8 +672,8 @@ enum aarch64_syscall { aarch64_sys_vmsplice = 75, aarch64_sys_splice = 76, aarch64_sys_tee = 77, - aarch64_sys_readlink = 78, - aarch64_sys_fstatat = 79, + aarch64_sys_readlinkat = 78, + aarch64_sys_newfstatat = 79, aarch64_sys_fstat = 80, aarch64_sys_sync = 81, aarch64_sys_fsync = 82, @@ -648,6 +866,9 @@ aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number) #define SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \ return gdb_sys_##SYSCALL +#define UNSUPPORTED_SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \ + return gdb_sys_no_syscall + switch (syscall_number) { SYSCALL_MAP (io_setup); @@ -670,33 +891,45 @@ aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number) SYSCALL_MAP (fremovexattr); SYSCALL_MAP (getcwd); SYSCALL_MAP (lookup_dcookie); - - case aarch64_sys_epoll_create1: - return gdb_sys_epoll_create; - + SYSCALL_MAP (eventfd2); + SYSCALL_MAP (epoll_create1); SYSCALL_MAP (epoll_ctl); SYSCALL_MAP (epoll_pwait); SYSCALL_MAP (dup); + SYSCALL_MAP (dup3); SYSCALL_MAP (fcntl); + SYSCALL_MAP (inotify_init1); SYSCALL_MAP (inotify_add_watch); SYSCALL_MAP (inotify_rm_watch); SYSCALL_MAP (ioctl); SYSCALL_MAP (ioprio_set); SYSCALL_MAP (ioprio_get); SYSCALL_MAP (flock); + SYSCALL_MAP (mknodat); + SYSCALL_MAP (mkdirat); + SYSCALL_MAP (unlinkat); + SYSCALL_MAP (symlinkat); + SYSCALL_MAP (linkat); + SYSCALL_MAP (renameat); + UNSUPPORTED_SYSCALL_MAP (umount2); SYSCALL_MAP (mount); + SYSCALL_MAP (pivot_root); SYSCALL_MAP (nfsservctl); SYSCALL_MAP (statfs); SYSCALL_MAP (truncate); SYSCALL_MAP (ftruncate); + SYSCALL_MAP (fallocate); + SYSCALL_MAP (faccessat); SYSCALL_MAP (fchdir); SYSCALL_MAP (chroot); SYSCALL_MAP (fchmod); SYSCALL_MAP (fchmodat); SYSCALL_MAP (fchownat); SYSCALL_MAP (fchown); + SYSCALL_MAP (openat); SYSCALL_MAP (close); SYSCALL_MAP (vhangup); + SYSCALL_MAP (pipe2); SYSCALL_MAP (quotactl); SYSCALL_MAP (getdents64); SYSCALL_MAP (lseek); @@ -706,17 +939,27 @@ aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number) SYSCALL_MAP (writev); SYSCALL_MAP (pread64); SYSCALL_MAP (pwrite64); + UNSUPPORTED_SYSCALL_MAP (preadv); + UNSUPPORTED_SYSCALL_MAP (pwritev); SYSCALL_MAP (sendfile); SYSCALL_MAP (pselect6); SYSCALL_MAP (ppoll); + UNSUPPORTED_SYSCALL_MAP (signalfd4); SYSCALL_MAP (vmsplice); SYSCALL_MAP (splice); SYSCALL_MAP (tee); + SYSCALL_MAP (readlinkat); + SYSCALL_MAP (newfstatat); + SYSCALL_MAP (fstat); SYSCALL_MAP (sync); SYSCALL_MAP (fsync); SYSCALL_MAP (fdatasync); SYSCALL_MAP (sync_file_range); + UNSUPPORTED_SYSCALL_MAP (timerfd_create); + UNSUPPORTED_SYSCALL_MAP (timerfd_settime); + UNSUPPORTED_SYSCALL_MAP (timerfd_gettime); + UNSUPPORTED_SYSCALL_MAP (utimensat); SYSCALL_MAP (acct); SYSCALL_MAP (capget); SYSCALL_MAP (capset); @@ -796,6 +1039,7 @@ aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number) SYSCALL_MAP (getrusage); SYSCALL_MAP (umask); SYSCALL_MAP (prctl); + SYSCALL_MAP (getcpu); SYSCALL_MAP (gettimeofday); SYSCALL_MAP (settimeofday); SYSCALL_MAP (adjtimex); @@ -870,7 +1114,28 @@ aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number) SYSCALL_MAP (set_mempolicy); SYSCALL_MAP (migrate_pages); SYSCALL_MAP (move_pages); - + UNSUPPORTED_SYSCALL_MAP (rt_tgsigqueueinfo); + UNSUPPORTED_SYSCALL_MAP (perf_event_open); + UNSUPPORTED_SYSCALL_MAP (accept4); + UNSUPPORTED_SYSCALL_MAP (recvmmsg); + + SYSCALL_MAP (wait4); + + UNSUPPORTED_SYSCALL_MAP (prlimit64); + UNSUPPORTED_SYSCALL_MAP (fanotify_init); + UNSUPPORTED_SYSCALL_MAP (fanotify_mark); + UNSUPPORTED_SYSCALL_MAP (name_to_handle_at); + UNSUPPORTED_SYSCALL_MAP (open_by_handle_at); + UNSUPPORTED_SYSCALL_MAP (clock_adjtime); + UNSUPPORTED_SYSCALL_MAP (syncfs); + UNSUPPORTED_SYSCALL_MAP (setns); + UNSUPPORTED_SYSCALL_MAP (sendmmsg); + UNSUPPORTED_SYSCALL_MAP (process_vm_readv); + UNSUPPORTED_SYSCALL_MAP (process_vm_writev); + UNSUPPORTED_SYSCALL_MAP (kcmp); + UNSUPPORTED_SYSCALL_MAP (finit_module); + UNSUPPORTED_SYSCALL_MAP (sched_setattr); + UNSUPPORTED_SYSCALL_MAP (sched_getattr); default: return gdb_sys_no_syscall; } @@ -939,6 +1204,15 @@ aarch64_linux_syscall_record (struct regcache *regcache, return 0; } +/* Implement the "gcc_target_options" gdbarch method. */ + +static char * +aarch64_linux_gcc_target_options (struct gdbarch *gdbarch) +{ + /* GCC doesn't know "-m64". */ + return NULL; +} + static void aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { @@ -972,6 +1246,8 @@ aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_iterate_over_regset_sections (gdbarch, aarch64_linux_iterate_over_regset_sections); + set_gdbarch_core_read_description + (gdbarch, aarch64_linux_core_read_description); /* SystemTap related. */ set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes); @@ -989,6 +1265,11 @@ aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) /* Syscall record. */ tdep->aarch64_syscall_record = aarch64_linux_syscall_record; + /* The top byte of a user space address known as the "tag", + is ignored by the kernel and can be regarded as additional + data associated with the address. */ + set_gdbarch_significant_addr_bit (gdbarch, 56); + /* Initialize the aarch64_linux_record_tdep. */ /* These values are the size of the type that will be used in a system call. They are obtained from Linux Kernel source. */ @@ -1009,8 +1290,7 @@ aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) aarch64_linux_record_tdep.size_old_gid_t = 2; aarch64_linux_record_tdep.size_old_uid_t = 2; aarch64_linux_record_tdep.size_fd_set = 128; - aarch64_linux_record_tdep.size_dirent = 280; - aarch64_linux_record_tdep.size_dirent64 = 280; + aarch64_linux_record_tdep.size_old_dirent = 280; aarch64_linux_record_tdep.size_statfs = 120; aarch64_linux_record_tdep.size_statfs64 = 120; aarch64_linux_record_tdep.size_sockaddr = 16; @@ -1054,7 +1334,7 @@ aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) aarch64_linux_record_tdep.size_epoll_event = 12; aarch64_linux_record_tdep.size_itimerspec = 32; aarch64_linux_record_tdep.size_mq_attr = 64; - aarch64_linux_record_tdep.size_termios = 60; + aarch64_linux_record_tdep.size_termios = 36; aarch64_linux_record_tdep.size_termios2 = 44; aarch64_linux_record_tdep.size_pid_t = 4; aarch64_linux_record_tdep.size_winsize = 8; @@ -1063,6 +1343,7 @@ aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) aarch64_linux_record_tdep.size_hayes_esp_config = 12; aarch64_linux_record_tdep.size_size_t = 8; aarch64_linux_record_tdep.size_iovec = 16; + aarch64_linux_record_tdep.size_time_t = 8; /* These values are the second argument of system call "sys_ioctl". They are obtained from Linux Kernel source. */ @@ -1158,15 +1439,12 @@ aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_displaced_step_copy_insn (gdbarch, aarch64_displaced_step_copy_insn); set_gdbarch_displaced_step_fixup (gdbarch, aarch64_displaced_step_fixup); - set_gdbarch_displaced_step_free_closure (gdbarch, - simple_displaced_step_free_closure); set_gdbarch_displaced_step_location (gdbarch, linux_displaced_step_location); set_gdbarch_displaced_step_hw_singlestep (gdbarch, aarch64_displaced_step_hw_singlestep); -} -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_aarch64_linux_tdep; + set_gdbarch_gcc_target_options (gdbarch, aarch64_linux_gcc_target_options); +} void _initialize_aarch64_linux_tdep (void)