gdb/aarch64-linux-tdep.c

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