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