gdb/aarch64-linux-tdep.c

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