gdbserver/linux-amd64-ipa.cc

   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.  */
  28 void init_registers_amd64_linux (void);
  29 extern 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
  52 static 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
  63 void
  64 supply_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
  74 ULONGEST
  75 get_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
  98 static 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
 132 void
 133 supply_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.  */
 173 static 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
 187 const struct target_desc *
 188 get_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
 228 void *
 229 alloc_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
 275 void
 276 initialize_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 }