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, ®); 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