gdb/gdbserver/linux-amd64-ipa.c

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