1/* GNU/Linux/x86-64 specific low level interface, for the in-process
2   agent library for GDB.
3
4   Copyright (C) 2010-2023 Free Software Foundation, Inc.
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 "server.h"
22#include <sys/mman.h>
23#include "tracepoint.h"
24#include "linux-x86-tdesc.h"
25#include "gdbsupport/x86-xstate.h"
26
27/* Defined in auto-generated file amd64-linux.c.  */
28void init_registers_amd64_linux (void);
29extern const struct target_desc *tdesc_amd64_linux;
30
31/* fast tracepoints collect registers.  */
32
33#define FT_CR_RIP 0
34#define FT_CR_EFLAGS 1
35#define FT_CR_R8 2
36#define FT_CR_R9 3
37#define FT_CR_R10 4
38#define FT_CR_R11 5
39#define FT_CR_R12 6
40#define FT_CR_R13 7
41#define FT_CR_R14 8
42#define FT_CR_R15 9
43#define FT_CR_RAX 10
44#define FT_CR_RBX 11
45#define FT_CR_RCX 12
46#define FT_CR_RDX 13
47#define FT_CR_RSI 14
48#define FT_CR_RDI 15
49#define FT_CR_RBP 16
50#define FT_CR_RSP 17
51
52static const int x86_64_ft_collect_regmap[] = {
53  FT_CR_RAX * 8, FT_CR_RBX * 8, FT_CR_RCX * 8, FT_CR_RDX * 8,
54  FT_CR_RSI * 8, FT_CR_RDI * 8, FT_CR_RBP * 8, FT_CR_RSP * 8,
55  FT_CR_R8 * 8,  FT_CR_R9 * 8,  FT_CR_R10 * 8, FT_CR_R11 * 8,
56  FT_CR_R12 * 8, FT_CR_R13 * 8, FT_CR_R14 * 8, FT_CR_R15 * 8,
57  FT_CR_RIP * 8, FT_CR_EFLAGS * 8
58};
59
60#define X86_64_NUM_FT_COLLECT_GREGS \
61  (sizeof (x86_64_ft_collect_regmap) / sizeof(x86_64_ft_collect_regmap[0]))
62
63void
64supply_fast_tracepoint_registers (struct regcache *regcache,
65				  const unsigned char *buf)
66{
67  int i;
68
69  for (i = 0; i < X86_64_NUM_FT_COLLECT_GREGS; i++)
70    supply_register (regcache, i,
71		     ((char *) buf) + x86_64_ft_collect_regmap[i]);
72}
73
74ULONGEST
75get_raw_reg (const unsigned char *raw_regs, int regnum)
76{
77  if (regnum >= X86_64_NUM_FT_COLLECT_GREGS)
78    return 0;
79
80  return *(ULONGEST *) (raw_regs + x86_64_ft_collect_regmap[regnum]);
81}
82
83#ifdef HAVE_UST
84
85#include <ust/processor.h>
86
87/* "struct registers" is the UST object type holding the registers at
88   the time of the static tracepoint marker call.  This doesn't
89   contain RIP, but we know what it must have been (the marker
90   address).  */
91
92#define ST_REGENTRY(REG)			\
93  {						\
94    offsetof (struct registers, REG),		\
95    sizeof (((struct registers *) NULL)->REG)	\
96  }
97
98static struct
99{
100  int offset;
101  int size;
102} x86_64_st_collect_regmap[] =
103  {
104    ST_REGENTRY(rax),
105    ST_REGENTRY(rbx),
106    ST_REGENTRY(rcx),
107    ST_REGENTRY(rdx),
108    ST_REGENTRY(rsi),
109    ST_REGENTRY(rdi),
110    ST_REGENTRY(rbp),
111    ST_REGENTRY(rsp),
112    ST_REGENTRY(r8),
113    ST_REGENTRY(r9),
114    ST_REGENTRY(r10),
115    ST_REGENTRY(r11),
116    ST_REGENTRY(r12),
117    ST_REGENTRY(r13),
118    ST_REGENTRY(r14),
119    ST_REGENTRY(r15),
120    { -1, 0 },
121    ST_REGENTRY(rflags),
122    ST_REGENTRY(cs),
123    ST_REGENTRY(ss),
124  };
125
126#define X86_64_NUM_ST_COLLECT_GREGS \
127  (sizeof (x86_64_st_collect_regmap) / sizeof (x86_64_st_collect_regmap[0]))
128
129/* GDB's RIP register number.  */
130#define AMD64_RIP_REGNUM 16
131
132void
133supply_static_tracepoint_registers (struct regcache *regcache,
134				    const unsigned char *buf,
135				    CORE_ADDR pc)
136{
137  int i;
138  unsigned long newpc = pc;
139
140  supply_register (regcache, AMD64_RIP_REGNUM, &newpc);
141
142  for (i = 0; i < X86_64_NUM_ST_COLLECT_GREGS; i++)
143    if (x86_64_st_collect_regmap[i].offset != -1)
144      {
145	switch (x86_64_st_collect_regmap[i].size)
146	  {
147	  case 8:
148	    supply_register (regcache, i,
149			     ((char *) buf)
150			     + x86_64_st_collect_regmap[i].offset);
151	    break;
152	  case 2:
153	    {
154	      unsigned long reg
155		= * (short *) (((char *) buf)
156			       + x86_64_st_collect_regmap[i].offset);
157	      reg &= 0xffff;
158	      supply_register (regcache, i, &reg);
159	    }
160	    break;
161	  default:
162	    internal_error ("unhandled register size: %d",
163			    x86_64_st_collect_regmap[i].size);
164	    break;
165	  }
166      }
167}
168
169#endif /* HAVE_UST */
170
171#if !defined __ILP32__
172/* Map the tdesc index to xcr0 mask.  */
173static uint64_t idx2mask[X86_TDESC_LAST] = {
174  X86_XSTATE_X87_MASK,
175  X86_XSTATE_SSE_MASK,
176  X86_XSTATE_AVX_MASK,
177  X86_XSTATE_MPX_MASK,
178  X86_XSTATE_AVX_MPX_MASK,
179  X86_XSTATE_AVX_AVX512_MASK,
180  X86_XSTATE_AVX_MPX_AVX512_PKU_MASK,
181};
182#endif
183
184/* Return target_desc to use for IPA, given the tdesc index passed by
185   gdbserver.  */
186
187const struct target_desc *
188get_ipa_tdesc (int idx)
189{
190  if (idx >= X86_TDESC_LAST)
191    {
192      internal_error ("unknown ipa tdesc index: %d", idx);
193    }
194
195#if defined __ILP32__
196  switch (idx)
197    {
198    case X86_TDESC_SSE:
199      return amd64_linux_read_description (X86_XSTATE_SSE_MASK, true);
200    case X86_TDESC_AVX:
201      return amd64_linux_read_description (X86_XSTATE_AVX_MASK, true);
202    case X86_TDESC_AVX_AVX512:
203      return amd64_linux_read_description (X86_XSTATE_AVX_AVX512_MASK, true);
204    default:
205      break;
206    }
207#else
208  return amd64_linux_read_description (idx2mask[idx], false);
209#endif
210
211  internal_error ("unknown ipa tdesc index: %d", idx);
212}
213
214/* Allocate buffer for the jump pads.  The branch instruction has a
215   reach of +/- 31-bit, and the executable is loaded at low addresses.
216
217   64-bit: Use MAP_32BIT to allocate in the first 2GB.  Shared
218   libraries, being allocated at the top, are unfortunately out of
219   luck.
220
221   x32: Since MAP_32BIT is 64-bit only, do the placement manually.
222   Try allocating at '0x80000000 - SIZE' initially, decreasing until
223   we hit a free area.  This ensures the executable is fully covered,
224   and is as close as possible to the shared libraries, which are
225   usually mapped at the top of the first 4GB of the address space.
226*/
227
228void *
229alloc_jump_pad_buffer (size_t size)
230{
231#if __ILP32__
232  uintptr_t addr;
233  int pagesize;
234
235  pagesize = sysconf (_SC_PAGE_SIZE);
236  if (pagesize == -1)
237    perror_with_name ("sysconf");
238
239  addr = 0x80000000 - size;
240
241  /* size should already be page-aligned, but this can't hurt.  */
242  addr &= ~(pagesize - 1);
243
244  /* Search for a free area.  If we hit 0, we're out of luck.  */
245  for (; addr; addr -= pagesize)
246    {
247      void *res;
248
249      /* No MAP_FIXED - we don't want to zap someone's mapping.  */
250      res = mmap ((void *) addr, size,
251		  PROT_READ | PROT_WRITE | PROT_EXEC,
252		  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
253
254      /* If we got what we wanted, return.  */
255      if ((uintptr_t) res == addr)
256	return res;
257
258      /* If we got a mapping, but at a wrong address, undo it.  */
259      if (res != MAP_FAILED)
260	munmap (res, size);
261    }
262
263  return NULL;
264#else
265  void *res = mmap (NULL, size, PROT_READ | PROT_WRITE | PROT_EXEC,
266		    MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT, -1, 0);
267
268  if (res == MAP_FAILED)
269    return NULL;
270
271  return res;
272#endif
273}
274
275void
276initialize_low_tracepoint (void)
277{
278#if defined __ILP32__
279  amd64_linux_read_description (X86_XSTATE_SSE_MASK, true);
280  amd64_linux_read_description (X86_XSTATE_AVX_MASK, true);
281  amd64_linux_read_description (X86_XSTATE_AVX_AVX512_MASK, true);
282#else
283  for (auto i = 0; i < X86_TDESC_LAST; i++)
284    amd64_linux_read_description (idx2mask[i], false);
285#endif
286}
287