gdb/aarch64-linux-tdep.c

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