1/* GNU/Linux/x86-64 specific low level interface, for the in-process
2   agent library for GDB.
3
4   Copyright (C) 2010-2020 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 (__FILE__, __LINE__,
163			    "unhandled register size: %d",
164			    x86_64_st_collect_regmap[i].size);
165	    break;
166	  }
167      }
168}
169
170#endif /* HAVE_UST */
171
172#if !defined __ILP32__
173/* Map the tdesc index to xcr0 mask.  */
174static uint64_t idx2mask[X86_TDESC_LAST] = {
175  X86_XSTATE_X87_MASK,
176  X86_XSTATE_SSE_MASK,
177  X86_XSTATE_AVX_MASK,
178  X86_XSTATE_MPX_MASK,
179  X86_XSTATE_AVX_MPX_MASK,
180  X86_XSTATE_AVX_AVX512_MASK,
181  X86_XSTATE_AVX_MPX_AVX512_PKU_MASK,
182};
183#endif
184
185/* Return target_desc to use for IPA, given the tdesc index passed by
186   gdbserver.  */
187
188const struct target_desc *
189get_ipa_tdesc (int idx)
190{
191  if (idx >= X86_TDESC_LAST)
192    {
193      internal_error (__FILE__, __LINE__,
194		      "unknown ipa tdesc index: %d", idx);
195    }
196
197#if defined __ILP32__
198  switch (idx)
199    {
200    case X86_TDESC_SSE:
201      return amd64_linux_read_description (X86_XSTATE_SSE_MASK, true);
202    case X86_TDESC_AVX:
203      return amd64_linux_read_description (X86_XSTATE_AVX_MASK, true);
204    case X86_TDESC_AVX_AVX512:
205      return amd64_linux_read_description (X86_XSTATE_AVX_AVX512_MASK, true);
206    default:
207      break;
208    }
209#else
210  return amd64_linux_read_description (idx2mask[idx], false);
211#endif
212
213  internal_error (__FILE__, __LINE__,
214		  "unknown ipa tdesc index: %d", idx);
215}
216
217/* Allocate buffer for the jump pads.  The branch instruction has a
218   reach of +/- 31-bit, and the executable is loaded at low addresses.
219
220   64-bit: Use MAP_32BIT to allocate in the first 2GB.  Shared
221   libraries, being allocated at the top, are unfortunately out of
222   luck.
223
224   x32: Since MAP_32BIT is 64-bit only, do the placement manually.
225   Try allocating at '0x80000000 - SIZE' initially, decreasing until
226   we hit a free area.  This ensures the executable is fully covered,
227   and is as close as possible to the shared libraries, which are
228   usually mapped at the top of the first 4GB of the address space.
229*/
230
231void *
232alloc_jump_pad_buffer (size_t size)
233{
234#if __ILP32__
235  uintptr_t addr;
236  int pagesize;
237
238  pagesize = sysconf (_SC_PAGE_SIZE);
239  if (pagesize == -1)
240    perror_with_name ("sysconf");
241
242  addr = 0x80000000 - size;
243
244  /* size should already be page-aligned, but this can't hurt.  */
245  addr &= ~(pagesize - 1);
246
247  /* Search for a free area.  If we hit 0, we're out of luck.  */
248  for (; addr; addr -= pagesize)
249    {
250      void *res;
251
252      /* No MAP_FIXED - we don't want to zap someone's mapping.  */
253      res = mmap ((void *) addr, size,
254		  PROT_READ | PROT_WRITE | PROT_EXEC,
255		  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
256
257      /* If we got what we wanted, return.  */
258      if ((uintptr_t) res == addr)
259	return res;
260
261      /* If we got a mapping, but at a wrong address, undo it.  */
262      if (res != MAP_FAILED)
263	munmap (res, size);
264    }
265
266  return NULL;
267#else
268  void *res = mmap (NULL, size, PROT_READ | PROT_WRITE | PROT_EXEC,
269		    MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT, -1, 0);
270
271  if (res == MAP_FAILED)
272    return NULL;
273
274  return res;
275#endif
276}
277
278void
279initialize_low_tracepoint (void)
280{
281#if defined __ILP32__
282  amd64_linux_read_description (X86_XSTATE_SSE_MASK, true);
283  amd64_linux_read_description (X86_XSTATE_AVX_MASK, true);
284  amd64_linux_read_description (X86_XSTATE_AVX_AVX512_MASK, true);
285#else
286  for (auto i = 0; i < X86_TDESC_LAST; i++)
287    amd64_linux_read_description (idx2mask[i], false);
288#endif
289}
290