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