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