gdb/aarch64-linux-tdep.c

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