gdb/aarch64-linux-tdep.c

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