gdb/aarch64-linux-tdep.c

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