gdb/aarch64-linux-tdep.c

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