gdb/aarch64-linux-tdep.c

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