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