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