gdb/aarch64-linux-tdep.c

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