gdb/aarch64-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux AArch64.
   2
   3    Copyright (C) 2009-2018 Free Software Foundation, Inc.
   4    Contributed by ARM Ltd.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22
  23 #include "gdbarch.h"
  24 #include "arch-utils.h"
  25 #include "glibc-tdep.h"
  26 #include "linux-tdep.h"
  27 #include "aarch64-tdep.h"
  28 #include "aarch64-linux-tdep.h"
  29 #include "osabi.h"
  30 #include "solib-svr4.h"
  31 #include "symtab.h"
  32 #include "tramp-frame.h"
  33 #include "trad-frame.h"
  34
  35 #include "inferior.h"
  36 #include "regcache.h"
  37 #include "regset.h"
  38
  39 #include "cli/cli-utils.h"
  40 #include "stap-probe.h"
  41 #include "parser-defs.h"
  42 #include "user-regs.h"
  43 #include "xml-syscall.h"
  44 #include <ctype.h>
  45
  46 #include "record-full.h"
  47 #include "linux-record.h"
  48 #include "auxv.h"
  49 #include "elf/common.h"
  50
  51 /* Signal frame handling.
  52
  53       +------------+  ^
  54       | saved lr   |  |
  55    +->| saved fp   |--+
  56    |  |            |
  57    |  |            |
  58    |  +------------+
  59    |  | saved lr   |
  60    +--| saved fp   |
  61    ^  |            |
  62    |  |            |
  63    |  +------------+
  64    ^  |            |
  65    |  | signal     |
  66    |  |            |        SIGTRAMP_FRAME (struct rt_sigframe)
  67    |  | saved regs |
  68    +--| saved sp   |--> interrupted_sp
  69    |  | saved pc   |--> interrupted_pc
  70    |  |            |
  71    |  +------------+
  72    |  | saved lr   |--> default_restorer (movz x8, NR_sys_rt_sigreturn; svc 0)
  73    +--| saved fp   |<- FP
  74       |            |         NORMAL_FRAME
  75       |            |<- SP
  76       +------------+
  77
  78   On signal delivery, the kernel will create a signal handler stack
  79   frame and setup the return address in LR to point at restorer stub.
  80   The signal stack frame is defined by:
  81
  82   struct rt_sigframe
  83   {
  84     siginfo_t info;
  85     struct ucontext uc;
  86   };
  87
  88   typedef struct
  89   {
  90     ...                                    128 bytes
  91   } siginfo_t;
  92
  93   The ucontext has the following form:
  94   struct ucontext
  95   {
  96     unsigned long uc_flags;
  97     struct ucontext *uc_link;
  98     stack_t uc_stack;
  99     sigset_t uc_sigmask;
 100     struct sigcontext uc_mcontext;
 101   };
 102
 103   typedef struct sigaltstack
 104   {
 105     void *ss_sp;
 106     int ss_flags;
 107     size_t ss_size;
 108   } stack_t;
 109
 110   struct sigcontext
 111   {
 112     unsigned long fault_address;
 113     unsigned long regs[31];
 114     unsigned long sp;           / * 31 * /
 115     unsigned long pc;           / * 32 * /
 116     unsigned long pstate;       / * 33 * /
 117     __u8 __reserved[4096]
 118   };
 119
 120   The restorer stub will always have the form:
 121
 122   d28015a8        movz    x8, #0xad
 123   d4000001        svc     #0x0
 124
 125   This is a system call sys_rt_sigreturn.
 126
 127   We detect signal frames by snooping the return code for the restorer
 128   instruction sequence.
 129
 130   The handler then needs to recover the saved register set from
 131   ucontext.uc_mcontext.  */
 132
 133 /* These magic numbers need to reflect the layout of the kernel
 134    defined struct rt_sigframe and ucontext.  */
 135 #define AARCH64_SIGCONTEXT_REG_SIZE             8
 136 #define AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET     128
 137 #define AARCH64_UCONTEXT_SIGCONTEXT_OFFSET      176
 138 #define AARCH64_SIGCONTEXT_XO_OFFSET            8
 139
 140 /* Implement the "init" method of struct tramp_frame.  */
 141
 142 static void
 143 aarch64_linux_sigframe_init (const struct tramp_frame *self,
 144                              struct frame_info *this_frame,
 145                              struct trad_frame_cache *this_cache,
 146                              CORE_ADDR func)
 147 {
 148   CORE_ADDR sp = get_frame_register_unsigned (this_frame, AARCH64_SP_REGNUM);
 149   CORE_ADDR sigcontext_addr =
 150     sp
 151     + AARCH64_RT_SIGFRAME_UCONTEXT_OFFSET
 152     + AARCH64_UCONTEXT_SIGCONTEXT_OFFSET;
 153   int i;
 154
 155   for (i = 0; i < 31; i++)
 156     {
 157       trad_frame_set_reg_addr (this_cache,
 158                                AARCH64_X0_REGNUM + i,
 159                                sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
 160                                + i * AARCH64_SIGCONTEXT_REG_SIZE);
 161     }
 162   trad_frame_set_reg_addr (this_cache, AARCH64_SP_REGNUM,
 163                            sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
 164                              + 31 * AARCH64_SIGCONTEXT_REG_SIZE);
 165   trad_frame_set_reg_addr (this_cache, AARCH64_PC_REGNUM,
 166                            sigcontext_addr + AARCH64_SIGCONTEXT_XO_OFFSET
 167                              + 32 * AARCH64_SIGCONTEXT_REG_SIZE);
 168
 169   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 170 }
 171
 172 static const struct tramp_frame aarch64_linux_rt_sigframe =
 173 {
 174   SIGTRAMP_FRAME,
 175   4,
 176   {
 177     /* movz x8, 0x8b (S=1,o=10,h=0,i=0x8b,r=8)
 178        Soo1 0010 1hhi iiii iiii iiii iiir rrrr  */
 179     {0xd2801168, -1},
 180
 181     /* svc  0x0      (o=0, l=1)
 182        1101 0100 oooi iiii iiii iiii iii0 00ll  */
 183     {0xd4000001, -1},
 184     {TRAMP_SENTINEL_INSN, -1}
 185   },
 186   aarch64_linux_sigframe_init
 187 };
 188
 189 /* Register maps.  */
 190
 191 static const struct regcache_map_entry aarch64_linux_gregmap[] =
 192   {
 193     { 31, AARCH64_X0_REGNUM, 8 }, /* x0 ... x30 */
 194     { 1, AARCH64_SP_REGNUM, 8 },
 195     { 1, AARCH64_PC_REGNUM, 8 },
 196     { 1, AARCH64_CPSR_REGNUM, 8 },
 197     { 0 }
 198   };
 199
 200 static const struct regcache_map_entry aarch64_linux_fpregmap[] =
 201   {
 202     { 32, AARCH64_V0_REGNUM, 16 }, /* v0 ... v31 */
 203     { 1, AARCH64_FPSR_REGNUM, 4 },
 204     { 1, AARCH64_FPCR_REGNUM, 4 },
 205     { 0 }
 206   };
 207
 208 /* Register set definitions.  */
 209
 210 const struct regset aarch64_linux_gregset =
 211   {
 212     aarch64_linux_gregmap,
 213     regcache_supply_regset, regcache_collect_regset
 214   };
 215
 216 const struct regset aarch64_linux_fpregset =
 217   {
 218     aarch64_linux_fpregmap,
 219     regcache_supply_regset, regcache_collect_regset
 220   };
 221
 222 /* The fields in an SVE header at the start of a SVE regset.  */
 223
 224 #define SVE_HEADER_SIZE_LENGTH          4
 225 #define SVE_HEADER_MAX_SIZE_LENGTH      4
 226 #define SVE_HEADER_VL_LENGTH            2
 227 #define SVE_HEADER_MAX_VL_LENGTH        2
 228 #define SVE_HEADER_FLAGS_LENGTH         2
 229 #define SVE_HEADER_RESERVED_LENGTH      2
 230
 231 #define SVE_HEADER_SIZE_OFFSET          0
 232 #define SVE_HEADER_MAX_SIZE_OFFSET      \
 233   (SVE_HEADER_SIZE_OFFSET + SVE_HEADER_SIZE_LENGTH)
 234 #define SVE_HEADER_VL_OFFSET            \
 235   (SVE_HEADER_MAX_SIZE_OFFSET + SVE_HEADER_MAX_SIZE_LENGTH)
 236 #define SVE_HEADER_MAX_VL_OFFSET        \
 237   (SVE_HEADER_VL_OFFSET + SVE_HEADER_VL_LENGTH)
 238 #define SVE_HEADER_FLAGS_OFFSET         \
 239   (SVE_HEADER_MAX_VL_OFFSET + SVE_HEADER_MAX_VL_LENGTH)
 240 #define SVE_HEADER_RESERVED_OFFSET      \
 241   (SVE_HEADER_FLAGS_OFFSET + SVE_HEADER_FLAGS_LENGTH)
 242 #define SVE_HEADER_SIZE                 \
 243   (SVE_HEADER_RESERVED_OFFSET + SVE_HEADER_RESERVED_LENGTH)
 244
 245 /* Get VQ value from SVE section in the core dump.  */
 246
 247 static uint64_t
 248 aarch64_linux_core_read_vq (struct gdbarch *gdbarch, bfd *abfd)
 249 {
 250   gdb_byte header[SVE_HEADER_SIZE];
 251   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 252   asection *sve_section = bfd_get_section_by_name (abfd, ".reg-aarch-sve");
 253
 254   if (sve_section == nullptr)
 255     {
 256       /* No SVE state.  */
 257       return 0;
 258     }
 259
 260   size_t size = bfd_section_size (abfd, sve_section);
 261
 262   /* Check extended state size.  */
 263   if (size < SVE_HEADER_SIZE)
 264     {
 265       warning (_("'.reg-aarch-sve' section in core file too small."));
 266       return 0;
 267     }
 268
 269   if (!bfd_get_section_contents (abfd, sve_section, header, 0, SVE_HEADER_SIZE))
 270     {
 271       warning (_("Couldn't read sve header from "
 272                  "'.reg-aarch-sve' section in core file."));
 273       return 0;
 274     }
 275
 276   uint64_t vl = extract_unsigned_integer (header + SVE_HEADER_VL_OFFSET,
 277                                           SVE_HEADER_VL_LENGTH, byte_order);
 278   uint64_t vq = sve_vq_from_vl (vl);
 279
 280   if (vq > AARCH64_MAX_SVE_VQ)
 281     {
 282       warning (_("SVE Vector length in core file not supported by this version"
 283                  " of GDB.  (VQ=%ld)"), vq);
 284       return 0;
 285     }
 286   else if (vq == 0)
 287     {
 288       warning (_("SVE Vector length in core file is invalid. (VQ=%ld"), vq);
 289       return 0;
 290     }
 291
 292   return vq;
 293 }
 294
 295 /* Implement the "regset_from_core_section" gdbarch method.  */
 296
 297 static void
 298 aarch64_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 299                                             iterate_over_regset_sections_cb *cb,
 300                                             void *cb_data,
 301                                             const struct regcache *regcache)
 302 {
 303   cb (".reg", AARCH64_LINUX_SIZEOF_GREGSET, AARCH64_LINUX_SIZEOF_GREGSET,
 304       &aarch64_linux_gregset, NULL, cb_data);
 305   cb (".reg2", AARCH64_LINUX_SIZEOF_FPREGSET, AARCH64_LINUX_SIZEOF_FPREGSET,
 306       &aarch64_linux_fpregset, NULL, cb_data);
 307 }
 308
 309 /* Implement the "core_read_description" gdbarch method.  */
 310
 311 static const struct target_desc *
 312 aarch64_linux_core_read_description (struct gdbarch *gdbarch,
 313                                      struct target_ops *target, bfd *abfd)
 314 {
 315   CORE_ADDR aarch64_hwcap = 0;
 316
 317   if (target_auxv_search (target, AT_HWCAP, &aarch64_hwcap) != 1)
 318     return NULL;
 319
 320   return aarch64_read_description (aarch64_linux_core_read_vq (gdbarch, abfd));
 321 }
 322
 323 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
 324    gdbarch.h.  */
 325
 326 static int
 327 aarch64_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
 328 {
 329   return (*s == '#' || isdigit (*s) /* Literal number.  */
 330           || *s == '[' /* Register indirection.  */
 331           || isalpha (*s)); /* Register value.  */
 332 }
 333
 334 /* This routine is used to parse a special token in AArch64's assembly.
 335
 336    The special tokens parsed by it are:
 337
 338       - Register displacement (e.g, [fp, #-8])
 339
 340    It returns one if the special token has been parsed successfully,
 341    or zero if the current token is not considered special.  */
 342
 343 static int
 344 aarch64_stap_parse_special_token (struct gdbarch *gdbarch,
 345                                   struct stap_parse_info *p)
 346 {
 347   if (*p->arg == '[')
 348     {
 349       /* Temporary holder for lookahead.  */
 350       const char *tmp = p->arg;
 351       char *endp;
 352       /* Used to save the register name.  */
 353       const char *start;
 354       char *regname;
 355       int len;
 356       int got_minus = 0;
 357       long displacement;
 358       struct stoken str;
 359
 360       ++tmp;
 361       start = tmp;
 362
 363       /* Register name.  */
 364       while (isalnum (*tmp))
 365         ++tmp;
 366
 367       if (*tmp != ',')
 368         return 0;
 369
 370       len = tmp - start;
 371       regname = (char *) alloca (len + 2);
 372
 373       strncpy (regname, start, len);
 374       regname[len] = '\0';
 375
 376       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
 377         error (_("Invalid register name `%s' on expression `%s'."),
 378                regname, p->saved_arg);
 379
 380       ++tmp;
 381       tmp = skip_spaces (tmp);
 382       /* Now we expect a number.  It can begin with '#' or simply
 383          a digit.  */
 384       if (*tmp == '#')
 385         ++tmp;
 386
 387       if (*tmp == '-')
 388         {
 389           ++tmp;
 390           got_minus = 1;
 391         }
 392       else if (*tmp == '+')
 393         ++tmp;
 394
 395       if (!isdigit (*tmp))
 396         return 0;
 397
 398       displacement = strtol (tmp, &endp, 10);
 399       tmp = endp;
 400
 401       /* Skipping last `]'.  */
 402       if (*tmp++ != ']')
 403         return 0;
 404
 405       /* The displacement.  */
 406       write_exp_elt_opcode (&p->pstate, OP_LONG);
 407       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
 408       write_exp_elt_longcst (&p->pstate, displacement);
 409       write_exp_elt_opcode (&p->pstate, OP_LONG);
 410       if (got_minus)
 411         write_exp_elt_opcode (&p->pstate, UNOP_NEG);
 412
 413       /* The register name.  */
 414       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
 415       str.ptr = regname;
 416       str.length = len;
 417       write_exp_string (&p->pstate, str);
 418       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
 419
 420       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
 421
 422       /* Casting to the expected type.  */
 423       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
 424       write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
 425       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
 426
 427       write_exp_elt_opcode (&p->pstate, UNOP_IND);
 428
 429       p->arg = tmp;
 430     }
 431   else
 432     return 0;
 433
 434   return 1;
 435 }
 436
 437 /* Implement the "get_syscall_number" gdbarch method.  */
 438
 439 static LONGEST
 440 aarch64_linux_get_syscall_number (struct gdbarch *gdbarch,
 441                                   thread_info *thread)
 442 {
 443   struct regcache *regs = get_thread_regcache (thread);
 444   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 445
 446   /* The content of register x8.  */
 447   gdb_byte buf[X_REGISTER_SIZE];
 448   /* The result.  */
 449   LONGEST ret;
 450
 451   /* Getting the system call number from the register x8.  */
 452   regs->cooked_read (AARCH64_DWARF_X0 + 8, buf);
 453
 454   ret = extract_signed_integer (buf, X_REGISTER_SIZE, byte_order);
 455
 456   return ret;
 457 }
 458
 459 /* AArch64 process record-replay constructs: syscall, signal etc.  */
 460
 461 struct linux_record_tdep aarch64_linux_record_tdep;
 462
 463 /* Enum that defines the AArch64 linux specific syscall identifiers used for
 464    process record/replay.  */
 465
 466 enum aarch64_syscall {
 467   aarch64_sys_io_setup = 0,
 468   aarch64_sys_io_destroy = 1,
 469   aarch64_sys_io_submit = 2,
 470   aarch64_sys_io_cancel = 3,
 471   aarch64_sys_io_getevents = 4,
 472   aarch64_sys_setxattr = 5,
 473   aarch64_sys_lsetxattr = 6,
 474   aarch64_sys_fsetxattr = 7,
 475   aarch64_sys_getxattr = 8,
 476   aarch64_sys_lgetxattr = 9,
 477   aarch64_sys_fgetxattr = 10,
 478   aarch64_sys_listxattr = 11,
 479   aarch64_sys_llistxattr = 12,
 480   aarch64_sys_flistxattr = 13,
 481   aarch64_sys_removexattr = 14,
 482   aarch64_sys_lremovexattr = 15,
 483   aarch64_sys_fremovexattr = 16,
 484   aarch64_sys_getcwd = 17,
 485   aarch64_sys_lookup_dcookie = 18,
 486   aarch64_sys_eventfd2 = 19,
 487   aarch64_sys_epoll_create1 = 20,
 488   aarch64_sys_epoll_ctl = 21,
 489   aarch64_sys_epoll_pwait = 22,
 490   aarch64_sys_dup = 23,
 491   aarch64_sys_dup3 = 24,
 492   aarch64_sys_fcntl = 25,
 493   aarch64_sys_inotify_init1 = 26,
 494   aarch64_sys_inotify_add_watch = 27,
 495   aarch64_sys_inotify_rm_watch = 28,
 496   aarch64_sys_ioctl = 29,
 497   aarch64_sys_ioprio_set = 30,
 498   aarch64_sys_ioprio_get = 31,
 499   aarch64_sys_flock = 32,
 500   aarch64_sys_mknodat = 33,
 501   aarch64_sys_mkdirat = 34,
 502   aarch64_sys_unlinkat = 35,
 503   aarch64_sys_symlinkat = 36,
 504   aarch64_sys_linkat = 37,
 505   aarch64_sys_renameat = 38,
 506   aarch64_sys_umount2 = 39,
 507   aarch64_sys_mount = 40,
 508   aarch64_sys_pivot_root = 41,
 509   aarch64_sys_nfsservctl = 42,
 510   aarch64_sys_statfs = 43,
 511   aarch64_sys_fstatfs = 44,
 512   aarch64_sys_truncate = 45,
 513   aarch64_sys_ftruncate = 46,
 514   aarch64_sys_fallocate = 47,
 515   aarch64_sys_faccessat = 48,
 516   aarch64_sys_chdir = 49,
 517   aarch64_sys_fchdir = 50,
 518   aarch64_sys_chroot = 51,
 519   aarch64_sys_fchmod = 52,
 520   aarch64_sys_fchmodat = 53,
 521   aarch64_sys_fchownat = 54,
 522   aarch64_sys_fchown = 55,
 523   aarch64_sys_openat = 56,
 524   aarch64_sys_close = 57,
 525   aarch64_sys_vhangup = 58,
 526   aarch64_sys_pipe2 = 59,
 527   aarch64_sys_quotactl = 60,
 528   aarch64_sys_getdents64 = 61,
 529   aarch64_sys_lseek = 62,
 530   aarch64_sys_read = 63,
 531   aarch64_sys_write = 64,
 532   aarch64_sys_readv = 65,
 533   aarch64_sys_writev = 66,
 534   aarch64_sys_pread64 = 67,
 535   aarch64_sys_pwrite64 = 68,
 536   aarch64_sys_preadv = 69,
 537   aarch64_sys_pwritev = 70,
 538   aarch64_sys_sendfile = 71,
 539   aarch64_sys_pselect6 = 72,
 540   aarch64_sys_ppoll = 73,
 541   aarch64_sys_signalfd4 = 74,
 542   aarch64_sys_vmsplice = 75,
 543   aarch64_sys_splice = 76,
 544   aarch64_sys_tee = 77,
 545   aarch64_sys_readlinkat = 78,
 546   aarch64_sys_newfstatat = 79,
 547   aarch64_sys_fstat = 80,
 548   aarch64_sys_sync = 81,
 549   aarch64_sys_fsync = 82,
 550   aarch64_sys_fdatasync = 83,
 551   aarch64_sys_sync_file_range2 = 84,
 552   aarch64_sys_sync_file_range = 84,
 553   aarch64_sys_timerfd_create = 85,
 554   aarch64_sys_timerfd_settime = 86,
 555   aarch64_sys_timerfd_gettime = 87,
 556   aarch64_sys_utimensat = 88,
 557   aarch64_sys_acct = 89,
 558   aarch64_sys_capget = 90,
 559   aarch64_sys_capset = 91,
 560   aarch64_sys_personality = 92,
 561   aarch64_sys_exit = 93,
 562   aarch64_sys_exit_group = 94,
 563   aarch64_sys_waitid = 95,
 564   aarch64_sys_set_tid_address = 96,
 565   aarch64_sys_unshare = 97,
 566   aarch64_sys_futex = 98,
 567   aarch64_sys_set_robust_list = 99,
 568   aarch64_sys_get_robust_list = 100,
 569   aarch64_sys_nanosleep = 101,
 570   aarch64_sys_getitimer = 102,
 571   aarch64_sys_setitimer = 103,
 572   aarch64_sys_kexec_load = 104,
 573   aarch64_sys_init_module = 105,
 574   aarch64_sys_delete_module = 106,
 575   aarch64_sys_timer_create = 107,
 576   aarch64_sys_timer_gettime = 108,
 577   aarch64_sys_timer_getoverrun = 109,
 578   aarch64_sys_timer_settime = 110,
 579   aarch64_sys_timer_delete = 111,
 580   aarch64_sys_clock_settime = 112,
 581   aarch64_sys_clock_gettime = 113,
 582   aarch64_sys_clock_getres = 114,
 583   aarch64_sys_clock_nanosleep = 115,
 584   aarch64_sys_syslog = 116,
 585   aarch64_sys_ptrace = 117,
 586   aarch64_sys_sched_setparam = 118,
 587   aarch64_sys_sched_setscheduler = 119,
 588   aarch64_sys_sched_getscheduler = 120,
 589   aarch64_sys_sched_getparam = 121,
 590   aarch64_sys_sched_setaffinity = 122,
 591   aarch64_sys_sched_getaffinity = 123,
 592   aarch64_sys_sched_yield = 124,
 593   aarch64_sys_sched_get_priority_max = 125,
 594   aarch64_sys_sched_get_priority_min = 126,
 595   aarch64_sys_sched_rr_get_interval = 127,
 596   aarch64_sys_kill = 129,
 597   aarch64_sys_tkill = 130,
 598   aarch64_sys_tgkill = 131,
 599   aarch64_sys_sigaltstack = 132,
 600   aarch64_sys_rt_sigsuspend = 133,
 601   aarch64_sys_rt_sigaction = 134,
 602   aarch64_sys_rt_sigprocmask = 135,
 603   aarch64_sys_rt_sigpending = 136,
 604   aarch64_sys_rt_sigtimedwait = 137,
 605   aarch64_sys_rt_sigqueueinfo = 138,
 606   aarch64_sys_rt_sigreturn = 139,
 607   aarch64_sys_setpriority = 140,
 608   aarch64_sys_getpriority = 141,
 609   aarch64_sys_reboot = 142,
 610   aarch64_sys_setregid = 143,
 611   aarch64_sys_setgid = 144,
 612   aarch64_sys_setreuid = 145,
 613   aarch64_sys_setuid = 146,
 614   aarch64_sys_setresuid = 147,
 615   aarch64_sys_getresuid = 148,
 616   aarch64_sys_setresgid = 149,
 617   aarch64_sys_getresgid = 150,
 618   aarch64_sys_setfsuid = 151,
 619   aarch64_sys_setfsgid = 152,
 620   aarch64_sys_times = 153,
 621   aarch64_sys_setpgid = 154,
 622   aarch64_sys_getpgid = 155,
 623   aarch64_sys_getsid = 156,
 624   aarch64_sys_setsid = 157,
 625   aarch64_sys_getgroups = 158,
 626   aarch64_sys_setgroups = 159,
 627   aarch64_sys_uname = 160,
 628   aarch64_sys_sethostname = 161,
 629   aarch64_sys_setdomainname = 162,
 630   aarch64_sys_getrlimit = 163,
 631   aarch64_sys_setrlimit = 164,
 632   aarch64_sys_getrusage = 165,
 633   aarch64_sys_umask = 166,
 634   aarch64_sys_prctl = 167,
 635   aarch64_sys_getcpu = 168,
 636   aarch64_sys_gettimeofday = 169,
 637   aarch64_sys_settimeofday = 170,
 638   aarch64_sys_adjtimex = 171,
 639   aarch64_sys_getpid = 172,
 640   aarch64_sys_getppid = 173,
 641   aarch64_sys_getuid = 174,
 642   aarch64_sys_geteuid = 175,
 643   aarch64_sys_getgid = 176,
 644   aarch64_sys_getegid = 177,
 645   aarch64_sys_gettid = 178,
 646   aarch64_sys_sysinfo = 179,
 647   aarch64_sys_mq_open = 180,
 648   aarch64_sys_mq_unlink = 181,
 649   aarch64_sys_mq_timedsend = 182,
 650   aarch64_sys_mq_timedreceive = 183,
 651   aarch64_sys_mq_notify = 184,
 652   aarch64_sys_mq_getsetattr = 185,
 653   aarch64_sys_msgget = 186,
 654   aarch64_sys_msgctl = 187,
 655   aarch64_sys_msgrcv = 188,
 656   aarch64_sys_msgsnd = 189,
 657   aarch64_sys_semget = 190,
 658   aarch64_sys_semctl = 191,
 659   aarch64_sys_semtimedop = 192,
 660   aarch64_sys_semop = 193,
 661   aarch64_sys_shmget = 194,
 662   aarch64_sys_shmctl = 195,
 663   aarch64_sys_shmat = 196,
 664   aarch64_sys_shmdt = 197,
 665   aarch64_sys_socket = 198,
 666   aarch64_sys_socketpair = 199,
 667   aarch64_sys_bind = 200,
 668   aarch64_sys_listen = 201,
 669   aarch64_sys_accept = 202,
 670   aarch64_sys_connect = 203,
 671   aarch64_sys_getsockname = 204,
 672   aarch64_sys_getpeername = 205,
 673   aarch64_sys_sendto = 206,
 674   aarch64_sys_recvfrom = 207,
 675   aarch64_sys_setsockopt = 208,
 676   aarch64_sys_getsockopt = 209,
 677   aarch64_sys_shutdown = 210,
 678   aarch64_sys_sendmsg = 211,
 679   aarch64_sys_recvmsg = 212,
 680   aarch64_sys_readahead = 213,
 681   aarch64_sys_brk = 214,
 682   aarch64_sys_munmap = 215,
 683   aarch64_sys_mremap = 216,
 684   aarch64_sys_add_key = 217,
 685   aarch64_sys_request_key = 218,
 686   aarch64_sys_keyctl = 219,
 687   aarch64_sys_clone = 220,
 688   aarch64_sys_execve = 221,
 689   aarch64_sys_mmap = 222,
 690   aarch64_sys_fadvise64 = 223,
 691   aarch64_sys_swapon = 224,
 692   aarch64_sys_swapoff = 225,
 693   aarch64_sys_mprotect = 226,
 694   aarch64_sys_msync = 227,
 695   aarch64_sys_mlock = 228,
 696   aarch64_sys_munlock = 229,
 697   aarch64_sys_mlockall = 230,
 698   aarch64_sys_munlockall = 231,
 699   aarch64_sys_mincore = 232,
 700   aarch64_sys_madvise = 233,
 701   aarch64_sys_remap_file_pages = 234,
 702   aarch64_sys_mbind = 235,
 703   aarch64_sys_get_mempolicy = 236,
 704   aarch64_sys_set_mempolicy = 237,
 705   aarch64_sys_migrate_pages = 238,
 706   aarch64_sys_move_pages = 239,
 707   aarch64_sys_rt_tgsigqueueinfo = 240,
 708   aarch64_sys_perf_event_open = 241,
 709   aarch64_sys_accept4 = 242,
 710   aarch64_sys_recvmmsg = 243,
 711   aarch64_sys_wait4 = 260,
 712   aarch64_sys_prlimit64 = 261,
 713   aarch64_sys_fanotify_init = 262,
 714   aarch64_sys_fanotify_mark = 263,
 715   aarch64_sys_name_to_handle_at = 264,
 716   aarch64_sys_open_by_handle_at = 265,
 717   aarch64_sys_clock_adjtime = 266,
 718   aarch64_sys_syncfs = 267,
 719   aarch64_sys_setns = 268,
 720   aarch64_sys_sendmmsg = 269,
 721   aarch64_sys_process_vm_readv = 270,
 722   aarch64_sys_process_vm_writev = 271,
 723   aarch64_sys_kcmp = 272,
 724   aarch64_sys_finit_module = 273,
 725   aarch64_sys_sched_setattr = 274,
 726   aarch64_sys_sched_getattr = 275,
 727 };
 728
 729 /* aarch64_canonicalize_syscall maps syscall ids from the native AArch64
 730    linux set of syscall ids into a canonical set of syscall ids used by
 731    process record.  */
 732
 733 static enum gdb_syscall
 734 aarch64_canonicalize_syscall (enum aarch64_syscall syscall_number)
 735 {
 736 #define SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \
 737   return gdb_sys_##SYSCALL
 738
 739 #define UNSUPPORTED_SYSCALL_MAP(SYSCALL) case aarch64_sys_##SYSCALL: \
 740   return gdb_sys_no_syscall
 741
 742   switch (syscall_number)
 743     {
 744       SYSCALL_MAP (io_setup);
 745       SYSCALL_MAP (io_destroy);
 746       SYSCALL_MAP (io_submit);
 747       SYSCALL_MAP (io_cancel);
 748       SYSCALL_MAP (io_getevents);
 749
 750       SYSCALL_MAP (setxattr);
 751       SYSCALL_MAP (lsetxattr);
 752       SYSCALL_MAP (fsetxattr);
 753       SYSCALL_MAP (getxattr);
 754       SYSCALL_MAP (lgetxattr);
 755       SYSCALL_MAP (fgetxattr);
 756       SYSCALL_MAP (listxattr);
 757       SYSCALL_MAP (llistxattr);
 758       SYSCALL_MAP (flistxattr);
 759       SYSCALL_MAP (removexattr);
 760       SYSCALL_MAP (lremovexattr);
 761       SYSCALL_MAP (fremovexattr);
 762       SYSCALL_MAP (getcwd);
 763       SYSCALL_MAP (lookup_dcookie);
 764       SYSCALL_MAP (eventfd2);
 765       SYSCALL_MAP (epoll_create1);
 766       SYSCALL_MAP (epoll_ctl);
 767       SYSCALL_MAP (epoll_pwait);
 768       SYSCALL_MAP (dup);
 769       SYSCALL_MAP (dup3);
 770       SYSCALL_MAP (fcntl);
 771       SYSCALL_MAP (inotify_init1);
 772       SYSCALL_MAP (inotify_add_watch);
 773       SYSCALL_MAP (inotify_rm_watch);
 774       SYSCALL_MAP (ioctl);
 775       SYSCALL_MAP (ioprio_set);
 776       SYSCALL_MAP (ioprio_get);
 777       SYSCALL_MAP (flock);
 778       SYSCALL_MAP (mknodat);
 779       SYSCALL_MAP (mkdirat);
 780       SYSCALL_MAP (unlinkat);
 781       SYSCALL_MAP (symlinkat);
 782       SYSCALL_MAP (linkat);
 783       SYSCALL_MAP (renameat);
 784       UNSUPPORTED_SYSCALL_MAP (umount2);
 785       SYSCALL_MAP (mount);
 786       SYSCALL_MAP (pivot_root);
 787       SYSCALL_MAP (nfsservctl);
 788       SYSCALL_MAP (statfs);
 789       SYSCALL_MAP (truncate);
 790       SYSCALL_MAP (ftruncate);
 791       SYSCALL_MAP (fallocate);
 792       SYSCALL_MAP (faccessat);
 793       SYSCALL_MAP (fchdir);
 794       SYSCALL_MAP (chroot);
 795       SYSCALL_MAP (fchmod);
 796       SYSCALL_MAP (fchmodat);
 797       SYSCALL_MAP (fchownat);
 798       SYSCALL_MAP (fchown);
 799       SYSCALL_MAP (openat);
 800       SYSCALL_MAP (close);
 801       SYSCALL_MAP (vhangup);
 802       SYSCALL_MAP (pipe2);
 803       SYSCALL_MAP (quotactl);
 804       SYSCALL_MAP (getdents64);
 805       SYSCALL_MAP (lseek);
 806       SYSCALL_MAP (read);
 807       SYSCALL_MAP (write);
 808       SYSCALL_MAP (readv);
 809       SYSCALL_MAP (writev);
 810       SYSCALL_MAP (pread64);
 811       SYSCALL_MAP (pwrite64);
 812       UNSUPPORTED_SYSCALL_MAP (preadv);
 813       UNSUPPORTED_SYSCALL_MAP (pwritev);
 814       SYSCALL_MAP (sendfile);
 815       SYSCALL_MAP (pselect6);
 816       SYSCALL_MAP (ppoll);
 817       UNSUPPORTED_SYSCALL_MAP (signalfd4);
 818       SYSCALL_MAP (vmsplice);
 819       SYSCALL_MAP (splice);
 820       SYSCALL_MAP (tee);
 821       SYSCALL_MAP (readlinkat);
 822       SYSCALL_MAP (newfstatat);
 823
 824       SYSCALL_MAP (fstat);
 825       SYSCALL_MAP (sync);
 826       SYSCALL_MAP (fsync);
 827       SYSCALL_MAP (fdatasync);
 828       SYSCALL_MAP (sync_file_range);
 829       UNSUPPORTED_SYSCALL_MAP (timerfd_create);
 830       UNSUPPORTED_SYSCALL_MAP (timerfd_settime);
 831       UNSUPPORTED_SYSCALL_MAP (timerfd_gettime);
 832       UNSUPPORTED_SYSCALL_MAP (utimensat);
 833       SYSCALL_MAP (acct);
 834       SYSCALL_MAP (capget);
 835       SYSCALL_MAP (capset);
 836       SYSCALL_MAP (personality);
 837       SYSCALL_MAP (exit);
 838       SYSCALL_MAP (exit_group);
 839       SYSCALL_MAP (waitid);
 840       SYSCALL_MAP (set_tid_address);
 841       SYSCALL_MAP (unshare);
 842       SYSCALL_MAP (futex);
 843       SYSCALL_MAP (set_robust_list);
 844       SYSCALL_MAP (get_robust_list);
 845       SYSCALL_MAP (nanosleep);
 846
 847       SYSCALL_MAP (getitimer);
 848       SYSCALL_MAP (setitimer);
 849       SYSCALL_MAP (kexec_load);
 850       SYSCALL_MAP (init_module);
 851       SYSCALL_MAP (delete_module);
 852       SYSCALL_MAP (timer_create);
 853       SYSCALL_MAP (timer_settime);
 854       SYSCALL_MAP (timer_gettime);
 855       SYSCALL_MAP (timer_getoverrun);
 856       SYSCALL_MAP (timer_delete);
 857       SYSCALL_MAP (clock_settime);
 858       SYSCALL_MAP (clock_gettime);
 859       SYSCALL_MAP (clock_getres);
 860       SYSCALL_MAP (clock_nanosleep);
 861       SYSCALL_MAP (syslog);
 862       SYSCALL_MAP (ptrace);
 863       SYSCALL_MAP (sched_setparam);
 864       SYSCALL_MAP (sched_setscheduler);
 865       SYSCALL_MAP (sched_getscheduler);
 866       SYSCALL_MAP (sched_getparam);
 867       SYSCALL_MAP (sched_setaffinity);
 868       SYSCALL_MAP (sched_getaffinity);
 869       SYSCALL_MAP (sched_yield);
 870       SYSCALL_MAP (sched_get_priority_max);
 871       SYSCALL_MAP (sched_get_priority_min);
 872       SYSCALL_MAP (sched_rr_get_interval);
 873       SYSCALL_MAP (kill);
 874       SYSCALL_MAP (tkill);
 875       SYSCALL_MAP (tgkill);
 876       SYSCALL_MAP (sigaltstack);
 877       SYSCALL_MAP (rt_sigsuspend);
 878       SYSCALL_MAP (rt_sigaction);
 879       SYSCALL_MAP (rt_sigprocmask);
 880       SYSCALL_MAP (rt_sigpending);
 881       SYSCALL_MAP (rt_sigtimedwait);
 882       SYSCALL_MAP (rt_sigqueueinfo);
 883       SYSCALL_MAP (rt_sigreturn);
 884       SYSCALL_MAP (setpriority);
 885       SYSCALL_MAP (getpriority);
 886       SYSCALL_MAP (reboot);
 887       SYSCALL_MAP (setregid);
 888       SYSCALL_MAP (setgid);
 889       SYSCALL_MAP (setreuid);
 890       SYSCALL_MAP (setuid);
 891       SYSCALL_MAP (setresuid);
 892       SYSCALL_MAP (getresuid);
 893       SYSCALL_MAP (setresgid);
 894       SYSCALL_MAP (getresgid);
 895       SYSCALL_MAP (setfsuid);
 896       SYSCALL_MAP (setfsgid);
 897       SYSCALL_MAP (times);
 898       SYSCALL_MAP (setpgid);
 899       SYSCALL_MAP (getpgid);
 900       SYSCALL_MAP (getsid);
 901       SYSCALL_MAP (setsid);
 902       SYSCALL_MAP (getgroups);
 903       SYSCALL_MAP (setgroups);
 904       SYSCALL_MAP (uname);
 905       SYSCALL_MAP (sethostname);
 906       SYSCALL_MAP (setdomainname);
 907       SYSCALL_MAP (getrlimit);
 908       SYSCALL_MAP (setrlimit);
 909       SYSCALL_MAP (getrusage);
 910       SYSCALL_MAP (umask);
 911       SYSCALL_MAP (prctl);
 912       SYSCALL_MAP (getcpu);
 913       SYSCALL_MAP (gettimeofday);
 914       SYSCALL_MAP (settimeofday);
 915       SYSCALL_MAP (adjtimex);
 916       SYSCALL_MAP (getpid);
 917       SYSCALL_MAP (getppid);
 918       SYSCALL_MAP (getuid);
 919       SYSCALL_MAP (geteuid);
 920       SYSCALL_MAP (getgid);
 921       SYSCALL_MAP (getegid);
 922       SYSCALL_MAP (gettid);
 923       SYSCALL_MAP (sysinfo);
 924       SYSCALL_MAP (mq_open);
 925       SYSCALL_MAP (mq_unlink);
 926       SYSCALL_MAP (mq_timedsend);
 927       SYSCALL_MAP (mq_timedreceive);
 928       SYSCALL_MAP (mq_notify);
 929       SYSCALL_MAP (mq_getsetattr);
 930       SYSCALL_MAP (msgget);
 931       SYSCALL_MAP (msgctl);
 932       SYSCALL_MAP (msgrcv);
 933       SYSCALL_MAP (msgsnd);
 934       SYSCALL_MAP (semget);
 935       SYSCALL_MAP (semctl);
 936       SYSCALL_MAP (semtimedop);
 937       SYSCALL_MAP (semop);
 938       SYSCALL_MAP (shmget);
 939       SYSCALL_MAP (shmctl);
 940       SYSCALL_MAP (shmat);
 941       SYSCALL_MAP (shmdt);
 942       SYSCALL_MAP (socket);
 943       SYSCALL_MAP (socketpair);
 944       SYSCALL_MAP (bind);
 945       SYSCALL_MAP (listen);
 946       SYSCALL_MAP (accept);
 947       SYSCALL_MAP (connect);
 948       SYSCALL_MAP (getsockname);
 949       SYSCALL_MAP (getpeername);
 950       SYSCALL_MAP (sendto);
 951       SYSCALL_MAP (recvfrom);
 952       SYSCALL_MAP (setsockopt);
 953       SYSCALL_MAP (getsockopt);
 954       SYSCALL_MAP (shutdown);
 955       SYSCALL_MAP (sendmsg);
 956       SYSCALL_MAP (recvmsg);
 957       SYSCALL_MAP (readahead);
 958       SYSCALL_MAP (brk);
 959       SYSCALL_MAP (munmap);
 960       SYSCALL_MAP (mremap);
 961       SYSCALL_MAP (add_key);
 962       SYSCALL_MAP (request_key);
 963       SYSCALL_MAP (keyctl);
 964       SYSCALL_MAP (clone);
 965       SYSCALL_MAP (execve);
 966
 967     case aarch64_sys_mmap:
 968       return gdb_sys_mmap2;
 969
 970       SYSCALL_MAP (fadvise64);
 971       SYSCALL_MAP (swapon);
 972       SYSCALL_MAP (swapoff);
 973       SYSCALL_MAP (mprotect);
 974       SYSCALL_MAP (msync);
 975       SYSCALL_MAP (mlock);
 976       SYSCALL_MAP (munlock);
 977       SYSCALL_MAP (mlockall);
 978       SYSCALL_MAP (munlockall);
 979       SYSCALL_MAP (mincore);
 980       SYSCALL_MAP (madvise);
 981       SYSCALL_MAP (remap_file_pages);
 982       SYSCALL_MAP (mbind);
 983       SYSCALL_MAP (get_mempolicy);
 984       SYSCALL_MAP (set_mempolicy);
 985       SYSCALL_MAP (migrate_pages);
 986       SYSCALL_MAP (move_pages);
 987       UNSUPPORTED_SYSCALL_MAP (rt_tgsigqueueinfo);
 988       UNSUPPORTED_SYSCALL_MAP (perf_event_open);
 989       UNSUPPORTED_SYSCALL_MAP (accept4);
 990       UNSUPPORTED_SYSCALL_MAP (recvmmsg);
 991
 992       SYSCALL_MAP (wait4);
 993
 994       UNSUPPORTED_SYSCALL_MAP (prlimit64);
 995       UNSUPPORTED_SYSCALL_MAP (fanotify_init);
 996       UNSUPPORTED_SYSCALL_MAP (fanotify_mark);
 997       UNSUPPORTED_SYSCALL_MAP (name_to_handle_at);
 998       UNSUPPORTED_SYSCALL_MAP (open_by_handle_at);
 999       UNSUPPORTED_SYSCALL_MAP (clock_adjtime);
1000       UNSUPPORTED_SYSCALL_MAP (syncfs);
1001       UNSUPPORTED_SYSCALL_MAP (setns);
1002       UNSUPPORTED_SYSCALL_MAP (sendmmsg);
1003       UNSUPPORTED_SYSCALL_MAP (process_vm_readv);
1004       UNSUPPORTED_SYSCALL_MAP (process_vm_writev);
1005       UNSUPPORTED_SYSCALL_MAP (kcmp);
1006       UNSUPPORTED_SYSCALL_MAP (finit_module);
1007       UNSUPPORTED_SYSCALL_MAP (sched_setattr);
1008       UNSUPPORTED_SYSCALL_MAP (sched_getattr);
1009   default:
1010     return gdb_sys_no_syscall;
1011   }
1012 }
1013
1014 /* Record all registers but PC register for process-record.  */
1015
1016 static int
1017 aarch64_all_but_pc_registers_record (struct regcache *regcache)
1018 {
1019   int i;
1020
1021   for (i = AARCH64_X0_REGNUM; i < AARCH64_PC_REGNUM; i++)
1022     if (record_full_arch_list_add_reg (regcache, i))
1023       return -1;
1024
1025   if (record_full_arch_list_add_reg (regcache, AARCH64_CPSR_REGNUM))
1026     return -1;
1027
1028   return 0;
1029 }
1030
1031 /* Handler for aarch64 system call instruction recording.  */
1032
1033 static int
1034 aarch64_linux_syscall_record (struct regcache *regcache,
1035                               unsigned long svc_number)
1036 {
1037   int ret = 0;
1038   enum gdb_syscall syscall_gdb;
1039
1040   syscall_gdb =
1041     aarch64_canonicalize_syscall ((enum aarch64_syscall) svc_number);
1042
1043   if (syscall_gdb < 0)
1044     {
1045       printf_unfiltered (_("Process record and replay target doesn't "
1046                            "support syscall number %s\n"),
1047                          plongest (svc_number));
1048       return -1;
1049     }
1050
1051   if (syscall_gdb == gdb_sys_sigreturn
1052       || syscall_gdb == gdb_sys_rt_sigreturn)
1053    {
1054      if (aarch64_all_but_pc_registers_record (regcache))
1055        return -1;
1056      return 0;
1057    }
1058
1059   ret = record_linux_system_call (syscall_gdb, regcache,
1060                                   &aarch64_linux_record_tdep);
1061   if (ret != 0)
1062     return ret;
1063
1064   /* Record the return value of the system call.  */
1065   if (record_full_arch_list_add_reg (regcache, AARCH64_X0_REGNUM))
1066     return -1;
1067   /* Record LR.  */
1068   if (record_full_arch_list_add_reg (regcache, AARCH64_LR_REGNUM))
1069     return -1;
1070   /* Record CPSR.  */
1071   if (record_full_arch_list_add_reg (regcache, AARCH64_CPSR_REGNUM))
1072     return -1;
1073
1074   return 0;
1075 }
1076
1077 /* Implement the "gcc_target_options" gdbarch method.  */
1078
1079 static char *
1080 aarch64_linux_gcc_target_options (struct gdbarch *gdbarch)
1081 {
1082   /* GCC doesn't know "-m64".  */
1083   return NULL;
1084 }
1085
1086 static void
1087 aarch64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1088 {
1089   static const char *const stap_integer_prefixes[] = { "#", "", NULL };
1090   static const char *const stap_register_prefixes[] = { "", NULL };
1091   static const char *const stap_register_indirection_prefixes[] = { "[",
1092                                                                     NULL };
1093   static const char *const stap_register_indirection_suffixes[] = { "]",
1094                                                                     NULL };
1095   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1096
1097   tdep->lowest_pc = 0x8000;
1098
1099   linux_init_abi (info, gdbarch);
1100
1101   set_solib_svr4_fetch_link_map_offsets (gdbarch,
1102                                          svr4_lp64_fetch_link_map_offsets);
1103
1104   /* Enable TLS support.  */
1105   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1106                                              svr4_fetch_objfile_link_map);
1107
1108   /* Shared library handling.  */
1109   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1110   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1111
1112   tramp_frame_prepend_unwinder (gdbarch, &aarch64_linux_rt_sigframe);
1113
1114   /* Enable longjmp.  */
1115   tdep->jb_pc = 11;
1116
1117   set_gdbarch_iterate_over_regset_sections
1118     (gdbarch, aarch64_linux_iterate_over_regset_sections);
1119   set_gdbarch_core_read_description
1120     (gdbarch, aarch64_linux_core_read_description);
1121
1122   /* SystemTap related.  */
1123   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1124   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1125   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
1126                                             stap_register_indirection_prefixes);
1127   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
1128                                             stap_register_indirection_suffixes);
1129   set_gdbarch_stap_is_single_operand (gdbarch, aarch64_stap_is_single_operand);
1130   set_gdbarch_stap_parse_special_token (gdbarch,
1131                                         aarch64_stap_parse_special_token);
1132
1133   /* Reversible debugging, process record.  */
1134   set_gdbarch_process_record (gdbarch, aarch64_process_record);
1135   /* Syscall record.  */
1136   tdep->aarch64_syscall_record = aarch64_linux_syscall_record;
1137
1138   /* The top byte of a user space address known as the "tag",
1139      is ignored by the kernel and can be regarded as additional
1140      data associated with the address.  */
1141   set_gdbarch_significant_addr_bit (gdbarch, 56);
1142
1143   /* Initialize the aarch64_linux_record_tdep.  */
1144   /* These values are the size of the type that will be used in a system
1145      call.  They are obtained from Linux Kernel source.  */
1146   aarch64_linux_record_tdep.size_pointer
1147     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1148   aarch64_linux_record_tdep.size__old_kernel_stat = 32;
1149   aarch64_linux_record_tdep.size_tms = 32;
1150   aarch64_linux_record_tdep.size_loff_t = 8;
1151   aarch64_linux_record_tdep.size_flock = 32;
1152   aarch64_linux_record_tdep.size_oldold_utsname = 45;
1153   aarch64_linux_record_tdep.size_ustat = 32;
1154   aarch64_linux_record_tdep.size_old_sigaction = 32;
1155   aarch64_linux_record_tdep.size_old_sigset_t = 8;
1156   aarch64_linux_record_tdep.size_rlimit = 16;
1157   aarch64_linux_record_tdep.size_rusage = 144;
1158   aarch64_linux_record_tdep.size_timeval = 16;
1159   aarch64_linux_record_tdep.size_timezone = 8;
1160   aarch64_linux_record_tdep.size_old_gid_t = 2;
1161   aarch64_linux_record_tdep.size_old_uid_t = 2;
1162   aarch64_linux_record_tdep.size_fd_set = 128;
1163   aarch64_linux_record_tdep.size_old_dirent = 280;
1164   aarch64_linux_record_tdep.size_statfs = 120;
1165   aarch64_linux_record_tdep.size_statfs64 = 120;
1166   aarch64_linux_record_tdep.size_sockaddr = 16;
1167   aarch64_linux_record_tdep.size_int
1168     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1169   aarch64_linux_record_tdep.size_long
1170     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1171   aarch64_linux_record_tdep.size_ulong
1172     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1173   aarch64_linux_record_tdep.size_msghdr = 56;
1174   aarch64_linux_record_tdep.size_itimerval = 32;
1175   aarch64_linux_record_tdep.size_stat = 144;
1176   aarch64_linux_record_tdep.size_old_utsname = 325;
1177   aarch64_linux_record_tdep.size_sysinfo = 112;
1178   aarch64_linux_record_tdep.size_msqid_ds = 120;
1179   aarch64_linux_record_tdep.size_shmid_ds = 112;
1180   aarch64_linux_record_tdep.size_new_utsname = 390;
1181   aarch64_linux_record_tdep.size_timex = 208;
1182   aarch64_linux_record_tdep.size_mem_dqinfo = 24;
1183   aarch64_linux_record_tdep.size_if_dqblk = 72;
1184   aarch64_linux_record_tdep.size_fs_quota_stat = 80;
1185   aarch64_linux_record_tdep.size_timespec = 16;
1186   aarch64_linux_record_tdep.size_pollfd = 8;
1187   aarch64_linux_record_tdep.size_NFS_FHSIZE = 32;
1188   aarch64_linux_record_tdep.size_knfsd_fh = 132;
1189   aarch64_linux_record_tdep.size_TASK_COMM_LEN = 16;
1190   aarch64_linux_record_tdep.size_sigaction = 32;
1191   aarch64_linux_record_tdep.size_sigset_t = 8;
1192   aarch64_linux_record_tdep.size_siginfo_t = 128;
1193   aarch64_linux_record_tdep.size_cap_user_data_t = 8;
1194   aarch64_linux_record_tdep.size_stack_t = 24;
1195   aarch64_linux_record_tdep.size_off_t = 8;
1196   aarch64_linux_record_tdep.size_stat64 = 144;
1197   aarch64_linux_record_tdep.size_gid_t = 4;
1198   aarch64_linux_record_tdep.size_uid_t = 4;
1199   aarch64_linux_record_tdep.size_PAGE_SIZE = 4096;
1200   aarch64_linux_record_tdep.size_flock64 = 32;
1201   aarch64_linux_record_tdep.size_user_desc = 16;
1202   aarch64_linux_record_tdep.size_io_event = 32;
1203   aarch64_linux_record_tdep.size_iocb = 64;
1204   aarch64_linux_record_tdep.size_epoll_event = 12;
1205   aarch64_linux_record_tdep.size_itimerspec = 32;
1206   aarch64_linux_record_tdep.size_mq_attr = 64;
1207   aarch64_linux_record_tdep.size_termios = 36;
1208   aarch64_linux_record_tdep.size_termios2 = 44;
1209   aarch64_linux_record_tdep.size_pid_t = 4;
1210   aarch64_linux_record_tdep.size_winsize = 8;
1211   aarch64_linux_record_tdep.size_serial_struct = 72;
1212   aarch64_linux_record_tdep.size_serial_icounter_struct = 80;
1213   aarch64_linux_record_tdep.size_hayes_esp_config = 12;
1214   aarch64_linux_record_tdep.size_size_t = 8;
1215   aarch64_linux_record_tdep.size_iovec = 16;
1216   aarch64_linux_record_tdep.size_time_t = 8;
1217
1218   /* These values are the second argument of system call "sys_ioctl".
1219      They are obtained from Linux Kernel source.  */
1220   aarch64_linux_record_tdep.ioctl_TCGETS = 0x5401;
1221   aarch64_linux_record_tdep.ioctl_TCSETS = 0x5402;
1222   aarch64_linux_record_tdep.ioctl_TCSETSW = 0x5403;
1223   aarch64_linux_record_tdep.ioctl_TCSETSF = 0x5404;
1224   aarch64_linux_record_tdep.ioctl_TCGETA = 0x5405;
1225   aarch64_linux_record_tdep.ioctl_TCSETA = 0x5406;
1226   aarch64_linux_record_tdep.ioctl_TCSETAW = 0x5407;
1227   aarch64_linux_record_tdep.ioctl_TCSETAF = 0x5408;
1228   aarch64_linux_record_tdep.ioctl_TCSBRK = 0x5409;
1229   aarch64_linux_record_tdep.ioctl_TCXONC = 0x540a;
1230   aarch64_linux_record_tdep.ioctl_TCFLSH = 0x540b;
1231   aarch64_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
1232   aarch64_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
1233   aarch64_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
1234   aarch64_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
1235   aarch64_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
1236   aarch64_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
1237   aarch64_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
1238   aarch64_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
1239   aarch64_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
1240   aarch64_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
1241   aarch64_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
1242   aarch64_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
1243   aarch64_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
1244   aarch64_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
1245   aarch64_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
1246   aarch64_linux_record_tdep.ioctl_FIONREAD = 0x541b;
1247   aarch64_linux_record_tdep.ioctl_TIOCINQ = 0x541b;
1248   aarch64_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
1249   aarch64_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
1250   aarch64_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
1251   aarch64_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
1252   aarch64_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
1253   aarch64_linux_record_tdep.ioctl_FIONBIO = 0x5421;
1254   aarch64_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
1255   aarch64_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
1256   aarch64_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
1257   aarch64_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
1258   aarch64_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
1259   aarch64_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
1260   aarch64_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
1261   aarch64_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
1262   aarch64_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1263   aarch64_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1264   aarch64_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
1265   aarch64_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1266   aarch64_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1267   aarch64_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1268   aarch64_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1269   aarch64_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1270   aarch64_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1271   aarch64_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1272   aarch64_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1273   aarch64_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1274   aarch64_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1275   aarch64_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1276   aarch64_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1277   aarch64_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1278   aarch64_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
1279   aarch64_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
1280   aarch64_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
1281   aarch64_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
1282   aarch64_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
1283   aarch64_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
1284   aarch64_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1285
1286   /* These values are the second argument of system call "sys_fcntl"
1287      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1288   aarch64_linux_record_tdep.fcntl_F_GETLK = 5;
1289   aarch64_linux_record_tdep.fcntl_F_GETLK64 = 12;
1290   aarch64_linux_record_tdep.fcntl_F_SETLK64 = 13;
1291   aarch64_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1292
1293   /* The AArch64 syscall calling convention: reg x0-x6 for arguments,
1294      reg x8 for syscall number and return value in reg x0.  */
1295   aarch64_linux_record_tdep.arg1 = AARCH64_X0_REGNUM + 0;
1296   aarch64_linux_record_tdep.arg2 = AARCH64_X0_REGNUM + 1;
1297   aarch64_linux_record_tdep.arg3 = AARCH64_X0_REGNUM + 2;
1298   aarch64_linux_record_tdep.arg4 = AARCH64_X0_REGNUM + 3;
1299   aarch64_linux_record_tdep.arg5 = AARCH64_X0_REGNUM + 4;
1300   aarch64_linux_record_tdep.arg6 = AARCH64_X0_REGNUM + 5;
1301   aarch64_linux_record_tdep.arg7 = AARCH64_X0_REGNUM + 6;
1302
1303   /* `catch syscall' */
1304   set_xml_syscall_file_name (gdbarch, "syscalls/aarch64-linux.xml");
1305   set_gdbarch_get_syscall_number (gdbarch, aarch64_linux_get_syscall_number);
1306
1307   /* Displaced stepping.  */
1308   set_gdbarch_max_insn_length (gdbarch, 4 * DISPLACED_MODIFIED_INSNS);
1309   set_gdbarch_displaced_step_copy_insn (gdbarch,
1310                                         aarch64_displaced_step_copy_insn);
1311   set_gdbarch_displaced_step_fixup (gdbarch, aarch64_displaced_step_fixup);
1312   set_gdbarch_displaced_step_location (gdbarch, linux_displaced_step_location);
1313   set_gdbarch_displaced_step_hw_singlestep (gdbarch,
1314                                             aarch64_displaced_step_hw_singlestep);
1315
1316   set_gdbarch_gcc_target_options (gdbarch, aarch64_linux_gcc_target_options);
1317 }
1318
1319 void
1320 _initialize_aarch64_linux_tdep (void)
1321 {
1322   gdbarch_register_osabi (bfd_arch_aarch64, 0, GDB_OSABI_LINUX,
1323                           aarch64_linux_init_abi);
1324 }