Automatic date update in version.in
[binutils-gdb.git] / gdbserver / linux-aarch64-ipa.cc
blob99b7700ac4b90879b6f89e099ede24cd88c292a2
1 /* GNU/Linux/AArch64 specific low level interface, for the in-process
2 agent library for GDB.
4 Copyright (C) 2015-2024 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
21 #include <sys/mman.h>
22 #include "tracepoint.h"
23 #include <elf.h>
24 #ifdef HAVE_GETAUXVAL
25 #include <sys/auxv.h>
26 #endif
27 #include "linux-aarch64-tdesc.h"
29 /* Each register saved by the jump pad is in a 16 byte cell. */
30 #define FT_CR_SIZE 16
32 #define FT_CR_FPCR 0
33 #define FT_CR_FPSR 1
34 #define FT_CR_CPSR 2
35 #define FT_CR_PC 3
36 #define FT_CR_SP 4
37 #define FT_CR_X0 5
38 #define FT_CR_GPR(n) (FT_CR_X0 + (n))
39 #define FT_CR_FPR(n) (FT_CR_GPR (31) + (n))
41 /* Mapping between registers collected by the jump pad and GDB's register
42 array layout used by regcache.
44 See linux-aarch64-low.c (aarch64_install_fast_tracepoint_jump_pad) for
45 more details. */
47 static const int aarch64_ft_collect_regmap[] = {
48 FT_CR_GPR (0),
49 FT_CR_GPR (1),
50 FT_CR_GPR (2),
51 FT_CR_GPR (3),
52 FT_CR_GPR (4),
53 FT_CR_GPR (5),
54 FT_CR_GPR (6),
55 FT_CR_GPR (7),
56 FT_CR_GPR (8),
57 FT_CR_GPR (9),
58 FT_CR_GPR (10),
59 FT_CR_GPR (11),
60 FT_CR_GPR (12),
61 FT_CR_GPR (13),
62 FT_CR_GPR (14),
63 FT_CR_GPR (15),
64 FT_CR_GPR (16),
65 FT_CR_GPR (17),
66 FT_CR_GPR (18),
67 FT_CR_GPR (19),
68 FT_CR_GPR (20),
69 FT_CR_GPR (21),
70 FT_CR_GPR (22),
71 FT_CR_GPR (23),
72 FT_CR_GPR (24),
73 FT_CR_GPR (25),
74 FT_CR_GPR (26),
75 FT_CR_GPR (27),
76 FT_CR_GPR (28),
77 /* FP */
78 FT_CR_GPR (29),
79 /* LR */
80 FT_CR_GPR (30),
81 FT_CR_SP,
82 FT_CR_PC,
83 FT_CR_CPSR,
84 FT_CR_FPR (0),
85 FT_CR_FPR (1),
86 FT_CR_FPR (2),
87 FT_CR_FPR (3),
88 FT_CR_FPR (4),
89 FT_CR_FPR (5),
90 FT_CR_FPR (6),
91 FT_CR_FPR (7),
92 FT_CR_FPR (8),
93 FT_CR_FPR (9),
94 FT_CR_FPR (10),
95 FT_CR_FPR (11),
96 FT_CR_FPR (12),
97 FT_CR_FPR (13),
98 FT_CR_FPR (14),
99 FT_CR_FPR (15),
100 FT_CR_FPR (16),
101 FT_CR_FPR (17),
102 FT_CR_FPR (18),
103 FT_CR_FPR (19),
104 FT_CR_FPR (20),
105 FT_CR_FPR (21),
106 FT_CR_FPR (22),
107 FT_CR_FPR (23),
108 FT_CR_FPR (24),
109 FT_CR_FPR (25),
110 FT_CR_FPR (26),
111 FT_CR_FPR (27),
112 FT_CR_FPR (28),
113 FT_CR_FPR (29),
114 FT_CR_FPR (30),
115 FT_CR_FPR (31),
116 FT_CR_FPSR,
117 FT_CR_FPCR
120 #define AARCH64_NUM_FT_COLLECT_GREGS \
121 (sizeof (aarch64_ft_collect_regmap) / sizeof(aarch64_ft_collect_regmap[0]))
123 /* Fill in REGCACHE with registers saved by the jump pad in BUF. */
125 void
126 supply_fast_tracepoint_registers (struct regcache *regcache,
127 const unsigned char *buf)
129 int i;
131 for (i = 0; i < AARCH64_NUM_FT_COLLECT_GREGS; i++)
132 supply_register (regcache, i,
133 ((char *) buf)
134 + (aarch64_ft_collect_regmap[i] * FT_CR_SIZE));
137 ULONGEST
138 get_raw_reg (const unsigned char *raw_regs, int regnum)
140 if (regnum >= AARCH64_NUM_FT_COLLECT_GREGS)
141 return 0;
143 return *(ULONGEST *) (raw_regs
144 + aarch64_ft_collect_regmap[regnum] * FT_CR_SIZE);
147 /* Return target_desc to use for IPA, given the tdesc index passed by
148 gdbserver. Index is ignored, since we have only one tdesc
149 at the moment. SVE, pauth, MTE and TLS not yet supported. */
151 const struct target_desc *
152 get_ipa_tdesc (int idx)
154 return aarch64_linux_read_description ({});
157 /* Allocate buffer for the jump pads. The branch instruction has a reach
158 of +/- 128MiB, and the executable is loaded at 0x400000 (4MiB).
159 To maximize the area of executable that can use tracepoints, try
160 allocating at 0x400000 - size initially, decreasing until we hit
161 a free area. */
163 void *
164 alloc_jump_pad_buffer (size_t size)
166 uintptr_t addr;
167 uintptr_t exec_base = getauxval (AT_PHDR);
168 int pagesize;
169 void *res;
171 if (exec_base == 0)
172 exec_base = 0x400000;
174 pagesize = sysconf (_SC_PAGE_SIZE);
175 if (pagesize == -1)
176 perror_with_name ("sysconf");
178 addr = exec_base - size;
180 /* size should already be page-aligned, but this can't hurt. */
181 addr &= ~(pagesize - 1);
183 /* Search for a free area. If we hit 0, we're out of luck. */
184 for (; addr; addr -= pagesize)
186 /* No MAP_FIXED - we don't want to zap someone's mapping. */
187 res = mmap ((void *) addr, size,
188 PROT_READ | PROT_WRITE | PROT_EXEC,
189 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
191 /* If we got what we wanted, return. */
192 if ((uintptr_t) res == addr)
193 return res;
195 /* If we got a mapping, but at a wrong address, undo it. */
196 if (res != MAP_FAILED)
197 munmap (res, size);
200 return NULL;
203 void
204 initialize_low_tracepoint (void)
206 /* SVE, pauth, MTE and TLS not yet supported. */
207 aarch64_linux_read_description ({});