1//===-- RegisterContext_x86_64.cpp -------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include <cstring> 11#include <errno.h> 12#include <stdint.h> 13 14#include "lldb/Core/DataBufferHeap.h" 15#include "lldb/Core/DataExtractor.h" 16#include "lldb/Core/RegisterValue.h" 17#include "lldb/Core/Scalar.h" 18#include "lldb/Target/Target.h" 19#include "lldb/Target/Thread.h" 20#include "lldb/Host/Endian.h" 21#include "llvm/Support/Compiler.h" 22 23#include "ProcessPOSIX.h" 24#if defined(__linux__) or defined(__FreeBSD__) 25#include "ProcessMonitor.h" 26#endif 27#include "RegisterContext_i386.h" 28#include "RegisterContext_x86.h" 29#include "RegisterContext_x86_64.h" 30#include "Plugins/Process/elf-core/ProcessElfCore.h" 31 32using namespace lldb_private; 33using namespace lldb; 34 35// Support ptrace extensions even when compiled without required kernel support 36#ifndef NT_X86_XSTATE 37 #define NT_X86_XSTATE 0x202 38#endif 39 40enum 41{ 42 gcc_dwarf_gpr_rax = 0, 43 gcc_dwarf_gpr_rdx, 44 gcc_dwarf_gpr_rcx, 45 gcc_dwarf_gpr_rbx, 46 gcc_dwarf_gpr_rsi, 47 gcc_dwarf_gpr_rdi, 48 gcc_dwarf_gpr_rbp, 49 gcc_dwarf_gpr_rsp, 50 gcc_dwarf_gpr_r8, 51 gcc_dwarf_gpr_r9, 52 gcc_dwarf_gpr_r10, 53 gcc_dwarf_gpr_r11, 54 gcc_dwarf_gpr_r12, 55 gcc_dwarf_gpr_r13, 56 gcc_dwarf_gpr_r14, 57 gcc_dwarf_gpr_r15, 58 gcc_dwarf_gpr_rip, 59 gcc_dwarf_fpu_xmm0, 60 gcc_dwarf_fpu_xmm1, 61 gcc_dwarf_fpu_xmm2, 62 gcc_dwarf_fpu_xmm3, 63 gcc_dwarf_fpu_xmm4, 64 gcc_dwarf_fpu_xmm5, 65 gcc_dwarf_fpu_xmm6, 66 gcc_dwarf_fpu_xmm7, 67 gcc_dwarf_fpu_xmm8, 68 gcc_dwarf_fpu_xmm9, 69 gcc_dwarf_fpu_xmm10, 70 gcc_dwarf_fpu_xmm11, 71 gcc_dwarf_fpu_xmm12, 72 gcc_dwarf_fpu_xmm13, 73 gcc_dwarf_fpu_xmm14, 74 gcc_dwarf_fpu_xmm15, 75 gcc_dwarf_fpu_stmm0, 76 gcc_dwarf_fpu_stmm1, 77 gcc_dwarf_fpu_stmm2, 78 gcc_dwarf_fpu_stmm3, 79 gcc_dwarf_fpu_stmm4, 80 gcc_dwarf_fpu_stmm5, 81 gcc_dwarf_fpu_stmm6, 82 gcc_dwarf_fpu_stmm7, 83 gcc_dwarf_fpu_ymm0, 84 gcc_dwarf_fpu_ymm1, 85 gcc_dwarf_fpu_ymm2, 86 gcc_dwarf_fpu_ymm3, 87 gcc_dwarf_fpu_ymm4, 88 gcc_dwarf_fpu_ymm5, 89 gcc_dwarf_fpu_ymm6, 90 gcc_dwarf_fpu_ymm7, 91 gcc_dwarf_fpu_ymm8, 92 gcc_dwarf_fpu_ymm9, 93 gcc_dwarf_fpu_ymm10, 94 gcc_dwarf_fpu_ymm11, 95 gcc_dwarf_fpu_ymm12, 96 gcc_dwarf_fpu_ymm13, 97 gcc_dwarf_fpu_ymm14, 98 gcc_dwarf_fpu_ymm15 99}; 100 101enum 102{ 103 gdb_gpr_rax = 0, 104 gdb_gpr_rbx = 1, 105 gdb_gpr_rcx = 2, 106 gdb_gpr_rdx = 3, 107 gdb_gpr_rsi = 4, 108 gdb_gpr_rdi = 5, 109 gdb_gpr_rbp = 6, 110 gdb_gpr_rsp = 7, 111 gdb_gpr_r8 = 8, 112 gdb_gpr_r9 = 9, 113 gdb_gpr_r10 = 10, 114 gdb_gpr_r11 = 11, 115 gdb_gpr_r12 = 12, 116 gdb_gpr_r13 = 13, 117 gdb_gpr_r14 = 14, 118 gdb_gpr_r15 = 15, 119 gdb_gpr_rip = 16, 120 gdb_gpr_rflags = 17, 121 gdb_gpr_cs = 18, 122 gdb_gpr_ss = 19, 123 gdb_gpr_ds = 20, 124 gdb_gpr_es = 21, 125 gdb_gpr_fs = 22, 126 gdb_gpr_gs = 23, 127 gdb_fpu_stmm0 = 24, 128 gdb_fpu_stmm1 = 25, 129 gdb_fpu_stmm2 = 26, 130 gdb_fpu_stmm3 = 27, 131 gdb_fpu_stmm4 = 28, 132 gdb_fpu_stmm5 = 29, 133 gdb_fpu_stmm6 = 30, 134 gdb_fpu_stmm7 = 31, 135 gdb_fpu_fcw = 32, 136 gdb_fpu_fsw = 33, 137 gdb_fpu_ftw = 34, 138 gdb_fpu_cs_64 = 35, 139 gdb_fpu_ip = 36, 140 gdb_fpu_ds_64 = 37, 141 gdb_fpu_dp = 38, 142 gdb_fpu_fop = 39, 143 gdb_fpu_xmm0 = 40, 144 gdb_fpu_xmm1 = 41, 145 gdb_fpu_xmm2 = 42, 146 gdb_fpu_xmm3 = 43, 147 gdb_fpu_xmm4 = 44, 148 gdb_fpu_xmm5 = 45, 149 gdb_fpu_xmm6 = 46, 150 gdb_fpu_xmm7 = 47, 151 gdb_fpu_xmm8 = 48, 152 gdb_fpu_xmm9 = 49, 153 gdb_fpu_xmm10 = 50, 154 gdb_fpu_xmm11 = 51, 155 gdb_fpu_xmm12 = 52, 156 gdb_fpu_xmm13 = 53, 157 gdb_fpu_xmm14 = 54, 158 gdb_fpu_xmm15 = 55, 159 gdb_fpu_mxcsr = 56, 160 gdb_fpu_ymm0 = 57, 161 gdb_fpu_ymm1 = 58, 162 gdb_fpu_ymm2 = 59, 163 gdb_fpu_ymm3 = 60, 164 gdb_fpu_ymm4 = 61, 165 gdb_fpu_ymm5 = 62, 166 gdb_fpu_ymm6 = 63, 167 gdb_fpu_ymm7 = 64, 168 gdb_fpu_ymm8 = 65, 169 gdb_fpu_ymm9 = 66, 170 gdb_fpu_ymm10 = 67, 171 gdb_fpu_ymm11 = 68, 172 gdb_fpu_ymm12 = 69, 173 gdb_fpu_ymm13 = 70, 174 gdb_fpu_ymm14 = 71, 175 gdb_fpu_ymm15 = 72 176}; 177 178static const 179uint32_t g_gpr_regnums[k_num_gpr_registers] = 180{ 181 gpr_rax, 182 gpr_rbx, 183 gpr_rcx, 184 gpr_rdx, 185 gpr_rdi, 186 gpr_rsi, 187 gpr_rbp, 188 gpr_rsp, 189 gpr_r8, 190 gpr_r9, 191 gpr_r10, 192 gpr_r11, 193 gpr_r12, 194 gpr_r13, 195 gpr_r14, 196 gpr_r15, 197 gpr_rip, 198 gpr_rflags, 199 gpr_cs, 200 gpr_fs, 201 gpr_gs, 202 gpr_ss, 203 gpr_ds, 204 gpr_es, 205 gpr_eax, 206 gpr_ebx, 207 gpr_ecx, 208 gpr_edx, 209 gpr_edi, 210 gpr_esi, 211 gpr_ebp, 212 gpr_esp, 213 gpr_eip, 214 gpr_eflags 215}; 216 217static const uint32_t 218g_fpu_regnums[k_num_fpr_registers] = 219{ 220 fpu_fcw, 221 fpu_fsw, 222 fpu_ftw, 223 fpu_fop, 224 fpu_ip, 225 fpu_cs, 226 fpu_dp, 227 fpu_ds, 228 fpu_mxcsr, 229 fpu_mxcsrmask, 230 fpu_stmm0, 231 fpu_stmm1, 232 fpu_stmm2, 233 fpu_stmm3, 234 fpu_stmm4, 235 fpu_stmm5, 236 fpu_stmm6, 237 fpu_stmm7, 238 fpu_xmm0, 239 fpu_xmm1, 240 fpu_xmm2, 241 fpu_xmm3, 242 fpu_xmm4, 243 fpu_xmm5, 244 fpu_xmm6, 245 fpu_xmm7, 246 fpu_xmm8, 247 fpu_xmm9, 248 fpu_xmm10, 249 fpu_xmm11, 250 fpu_xmm12, 251 fpu_xmm13, 252 fpu_xmm14, 253 fpu_xmm15 254}; 255 256static const uint32_t 257g_avx_regnums[k_num_avx_registers] = 258{ 259 fpu_ymm0, 260 fpu_ymm1, 261 fpu_ymm2, 262 fpu_ymm3, 263 fpu_ymm4, 264 fpu_ymm5, 265 fpu_ymm6, 266 fpu_ymm7, 267 fpu_ymm8, 268 fpu_ymm9, 269 fpu_ymm10, 270 fpu_ymm11, 271 fpu_ymm12, 272 fpu_ymm13, 273 fpu_ymm14, 274 fpu_ymm15 275}; 276 277// Number of register sets provided by this context. 278enum 279{ 280 k_num_extended_register_sets = 1, 281 k_num_register_sets = 3 282}; 283 284static const RegisterSet 285g_reg_sets[k_num_register_sets] = 286{ 287 { "General Purpose Registers", "gpr", k_num_gpr_registers, g_gpr_regnums }, 288 { "Floating Point Registers", "fpu", k_num_fpr_registers, g_fpu_regnums }, 289 { "Advanced Vector Extensions", "avx", k_num_avx_registers, g_avx_regnums } 290}; 291 292// Computes the offset of the given FPR in the extended data area. 293#define FPR_OFFSET(regname) \ 294 (offsetof(RegisterContext_x86_64::FPR, xstate) + \ 295 offsetof(RegisterContext_x86_64::FXSAVE, regname)) 296 297// Computes the offset of the YMM register assembled from register halves. 298#define YMM_OFFSET(regname) \ 299 (offsetof(RegisterContext_x86_64::YMM, regname)) 300 301// Number of bytes needed to represent a i386 GPR 302#define GPR_i386_SIZE(reg) sizeof(((RegisterContext_i386::GPR*)NULL)->reg) 303 304// Number of bytes needed to represent a FPR. 305#define FPR_SIZE(reg) sizeof(((RegisterContext_x86_64::FXSAVE*)NULL)->reg) 306 307// Number of bytes needed to represent the i'th FP register. 308#define FP_SIZE sizeof(((RegisterContext_x86_64::MMSReg*)NULL)->bytes) 309 310// Number of bytes needed to represent an XMM register. 311#define XMM_SIZE sizeof(RegisterContext_x86_64::XMMReg) 312 313// Number of bytes needed to represent a YMM register. 314#define YMM_SIZE sizeof(RegisterContext_x86_64::YMMReg) 315 316// Note that the size and offset will be updated by platform-specific classes. 317#define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \ 318 { #reg, alt, 0, 0, eEncodingUint, \ 319 eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg }, NULL, NULL } 320 321// Dummy data for RegisterInfo::value_regs as expected by DumpRegisterSet. 322static uint32_t value_regs = LLDB_INVALID_REGNUM; 323 324#define DEFINE_GPR_i386(reg_i386, reg_x86_64, alt, kind1, kind2, kind3, kind4) \ 325 { #reg_i386, alt, GPR_i386_SIZE(reg_i386), 0, eEncodingUint, \ 326 eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg_i386 }, &value_regs, NULL } 327 328#define DEFINE_FPR(reg, kind1, kind2, kind3, kind4) \ 329 { #reg, NULL, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint, \ 330 eFormatHex, { kind1, kind2, kind3, kind4, fpu_##reg }, NULL, NULL } 331 332#define DEFINE_FP(reg, i) \ 333 { #reg#i, NULL, FP_SIZE, LLVM_EXTENSION FPR_OFFSET(reg[i]), \ 334 eEncodingVector, eFormatVectorOfUInt8, \ 335 { gcc_dwarf_fpu_##reg##i, gcc_dwarf_fpu_##reg##i, \ 336 LLDB_INVALID_REGNUM, gdb_fpu_##reg##i, fpu_##reg##i }, NULL, NULL } 337 338#define DEFINE_XMM(reg, i) \ 339 { #reg#i, NULL, XMM_SIZE, LLVM_EXTENSION FPR_OFFSET(reg[i]), \ 340 eEncodingVector, eFormatVectorOfUInt8, \ 341 { gcc_dwarf_fpu_##reg##i, gcc_dwarf_fpu_##reg##i, \ 342 LLDB_INVALID_REGNUM, gdb_fpu_##reg##i, fpu_##reg##i }, NULL, NULL } 343 344#define DEFINE_YMM(reg, i) \ 345 { #reg#i, NULL, YMM_SIZE, LLVM_EXTENSION YMM_OFFSET(reg[i]), \ 346 eEncodingVector, eFormatVectorOfUInt8, \ 347 { gcc_dwarf_fpu_##reg##i, gcc_dwarf_fpu_##reg##i, \ 348 LLDB_INVALID_REGNUM, gdb_fpu_##reg##i, fpu_##reg##i }, NULL, NULL } 349 350#define DEFINE_DR(reg, i) \ 351 { #reg#i, NULL, 0, 0, eEncodingUint, eFormatHex, \ 352 { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \ 353 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM }, NULL, NULL } 354 355#define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(RegisterContext_x86_64::FPR)) 356 357static RegisterInfo 358g_register_infos[k_num_registers] = 359{ 360 // General purpose registers. 361 DEFINE_GPR(rax, NULL, gcc_dwarf_gpr_rax, gcc_dwarf_gpr_rax, LLDB_INVALID_REGNUM, gdb_gpr_rax), 362 DEFINE_GPR(rbx, NULL, gcc_dwarf_gpr_rbx, gcc_dwarf_gpr_rbx, LLDB_INVALID_REGNUM, gdb_gpr_rbx), 363 DEFINE_GPR(rcx, NULL, gcc_dwarf_gpr_rcx, gcc_dwarf_gpr_rcx, LLDB_INVALID_REGNUM, gdb_gpr_rcx), 364 DEFINE_GPR(rdx, NULL, gcc_dwarf_gpr_rdx, gcc_dwarf_gpr_rdx, LLDB_INVALID_REGNUM, gdb_gpr_rdx), 365 DEFINE_GPR(rdi, NULL, gcc_dwarf_gpr_rdi, gcc_dwarf_gpr_rdi, LLDB_INVALID_REGNUM, gdb_gpr_rdi), 366 DEFINE_GPR(rsi, NULL, gcc_dwarf_gpr_rsi, gcc_dwarf_gpr_rsi, LLDB_INVALID_REGNUM, gdb_gpr_rsi), 367 DEFINE_GPR(rbp, "fp", gcc_dwarf_gpr_rbp, gcc_dwarf_gpr_rbp, LLDB_REGNUM_GENERIC_FP, gdb_gpr_rbp), 368 DEFINE_GPR(rsp, "sp", gcc_dwarf_gpr_rsp, gcc_dwarf_gpr_rsp, LLDB_REGNUM_GENERIC_SP, gdb_gpr_rsp), 369 DEFINE_GPR(r8, NULL, gcc_dwarf_gpr_r8, gcc_dwarf_gpr_r8, LLDB_INVALID_REGNUM, gdb_gpr_r8), 370 DEFINE_GPR(r9, NULL, gcc_dwarf_gpr_r9, gcc_dwarf_gpr_r9, LLDB_INVALID_REGNUM, gdb_gpr_r9), 371 DEFINE_GPR(r10, NULL, gcc_dwarf_gpr_r10, gcc_dwarf_gpr_r10, LLDB_INVALID_REGNUM, gdb_gpr_r10), 372 DEFINE_GPR(r11, NULL, gcc_dwarf_gpr_r11, gcc_dwarf_gpr_r11, LLDB_INVALID_REGNUM, gdb_gpr_r11), 373 DEFINE_GPR(r12, NULL, gcc_dwarf_gpr_r12, gcc_dwarf_gpr_r12, LLDB_INVALID_REGNUM, gdb_gpr_r12), 374 DEFINE_GPR(r13, NULL, gcc_dwarf_gpr_r13, gcc_dwarf_gpr_r13, LLDB_INVALID_REGNUM, gdb_gpr_r13), 375 DEFINE_GPR(r14, NULL, gcc_dwarf_gpr_r14, gcc_dwarf_gpr_r14, LLDB_INVALID_REGNUM, gdb_gpr_r14), 376 DEFINE_GPR(r15, NULL, gcc_dwarf_gpr_r15, gcc_dwarf_gpr_r15, LLDB_INVALID_REGNUM, gdb_gpr_r15), 377 DEFINE_GPR(rip, "pc", gcc_dwarf_gpr_rip, gcc_dwarf_gpr_rip, LLDB_REGNUM_GENERIC_PC, gdb_gpr_rip), 378 DEFINE_GPR(rflags, "flags", LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS, gdb_gpr_rflags), 379 DEFINE_GPR(cs, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_gpr_cs), 380 DEFINE_GPR(fs, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_gpr_fs), 381 DEFINE_GPR(gs, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_gpr_gs), 382 DEFINE_GPR(ss, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_gpr_ss), 383 DEFINE_GPR(ds, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_gpr_ds), 384 DEFINE_GPR(es, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_gpr_es), 385 // i386 registers 386 DEFINE_GPR_i386(eax, rax, NULL, gcc_eax, dwarf_eax, LLDB_INVALID_REGNUM, gdb_eax), 387 DEFINE_GPR_i386(ebx, rbx, NULL, gcc_ebx, dwarf_ebx, LLDB_INVALID_REGNUM, gdb_ebx), 388 DEFINE_GPR_i386(ecx, rcx, NULL, gcc_ecx, dwarf_ecx, LLDB_INVALID_REGNUM, gdb_ecx), 389 DEFINE_GPR_i386(edx, rdx, NULL, gcc_edx, dwarf_edx, LLDB_INVALID_REGNUM, gdb_edx), 390 DEFINE_GPR_i386(edi, rdi, NULL, gcc_edi, dwarf_edi, LLDB_INVALID_REGNUM, gdb_edi), 391 DEFINE_GPR_i386(esi, rsi, NULL, gcc_esi, dwarf_esi, LLDB_INVALID_REGNUM, gdb_esi), 392 DEFINE_GPR_i386(ebp, rbp, "fp", gcc_ebp, dwarf_ebp, LLDB_REGNUM_GENERIC_FP, gdb_ebp), 393 DEFINE_GPR_i386(esp, rsp, "sp", gcc_esp, dwarf_esp, LLDB_REGNUM_GENERIC_SP, gdb_esp), 394 DEFINE_GPR_i386(eip, rip, "pc", gcc_eip, dwarf_eip, LLDB_REGNUM_GENERIC_PC, gdb_eip), 395 DEFINE_GPR_i386(eflags, rflags, "flags", gcc_eflags, dwarf_eflags, LLDB_REGNUM_GENERIC_FLAGS, gdb_eflags), 396 // i387 Floating point registers. 397 DEFINE_FPR(fcw, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_fcw), 398 DEFINE_FPR(fsw, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_fsw), 399 DEFINE_FPR(ftw, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_ftw), 400 DEFINE_FPR(fop, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_fop), 401 DEFINE_FPR(ip, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_ip), 402 // FIXME: Extract segment from ip. 403 DEFINE_FPR(ip, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_cs_64), 404 DEFINE_FPR(dp, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_dp), 405 // FIXME: Extract segment from dp. 406 DEFINE_FPR(dp, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_ds_64), 407 DEFINE_FPR(mxcsr, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_mxcsr), 408 DEFINE_FPR(mxcsrmask, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM), 409 410 // FP registers. 411 DEFINE_FP(stmm, 0), 412 DEFINE_FP(stmm, 1), 413 DEFINE_FP(stmm, 2), 414 DEFINE_FP(stmm, 3), 415 DEFINE_FP(stmm, 4), 416 DEFINE_FP(stmm, 5), 417 DEFINE_FP(stmm, 6), 418 DEFINE_FP(stmm, 7), 419 420 // XMM registers 421 DEFINE_XMM(xmm, 0), 422 DEFINE_XMM(xmm, 1), 423 DEFINE_XMM(xmm, 2), 424 DEFINE_XMM(xmm, 3), 425 DEFINE_XMM(xmm, 4), 426 DEFINE_XMM(xmm, 5), 427 DEFINE_XMM(xmm, 6), 428 DEFINE_XMM(xmm, 7), 429 DEFINE_XMM(xmm, 8), 430 DEFINE_XMM(xmm, 9), 431 DEFINE_XMM(xmm, 10), 432 DEFINE_XMM(xmm, 11), 433 DEFINE_XMM(xmm, 12), 434 DEFINE_XMM(xmm, 13), 435 DEFINE_XMM(xmm, 14), 436 DEFINE_XMM(xmm, 15), 437 438 // Copy of YMM registers assembled from xmm and ymmh 439 DEFINE_YMM(ymm, 0), 440 DEFINE_YMM(ymm, 1), 441 DEFINE_YMM(ymm, 2), 442 DEFINE_YMM(ymm, 3), 443 DEFINE_YMM(ymm, 4), 444 DEFINE_YMM(ymm, 5), 445 DEFINE_YMM(ymm, 6), 446 DEFINE_YMM(ymm, 7), 447 DEFINE_YMM(ymm, 8), 448 DEFINE_YMM(ymm, 9), 449 DEFINE_YMM(ymm, 10), 450 DEFINE_YMM(ymm, 11), 451 DEFINE_YMM(ymm, 12), 452 DEFINE_YMM(ymm, 13), 453 DEFINE_YMM(ymm, 14), 454 DEFINE_YMM(ymm, 15), 455 456 // Debug registers for lldb internal use 457 DEFINE_DR(dr, 0), 458 DEFINE_DR(dr, 1), 459 DEFINE_DR(dr, 2), 460 DEFINE_DR(dr, 3), 461 DEFINE_DR(dr, 4), 462 DEFINE_DR(dr, 5), 463 DEFINE_DR(dr, 6), 464 DEFINE_DR(dr, 7) 465}; 466 467static bool IsGPR(unsigned reg) 468{ 469 return reg <= k_last_gpr; // GPR's come first. 470} 471 472static bool IsAVX(unsigned reg) 473{ 474 return (k_first_avx <= reg && reg <= k_last_avx); 475} 476static bool IsFPR(unsigned reg) 477{ 478 return (k_first_fpr <= reg && reg <= k_last_fpr); 479} 480 481 482bool RegisterContext_x86_64::IsFPR(unsigned reg, FPRType fpr_type) 483{ 484 bool generic_fpr = ::IsFPR(reg); 485 if (fpr_type == eXSAVE) 486 return generic_fpr || IsAVX(reg); 487 488 return generic_fpr; 489} 490 491RegisterContext_x86_64::RegisterContext_x86_64(Thread &thread, 492 uint32_t concrete_frame_idx) 493 : RegisterContextPOSIX(thread, concrete_frame_idx) 494{ 495 // Initialize m_iovec to point to the buffer and buffer size 496 // using the conventions of Berkeley style UIO structures, as required 497 // by PTRACE extensions. 498 m_iovec.iov_base = &m_fpr.xstate.xsave; 499 m_iovec.iov_len = sizeof(m_fpr.xstate.xsave); 500 501 ::memset(&m_fpr, 0, sizeof(RegisterContext_x86_64::FPR)); 502 503 // elf-core yet to support ReadFPR() 504 ProcessSP base = CalculateProcess(); 505 if (base.get()->GetPluginName() == ProcessElfCore::GetPluginNameStatic()) 506 return; 507 508 // TODO: Use assembly to call cpuid on the inferior and query ebx or ecx 509 m_fpr_type = eXSAVE; // extended floating-point registers, if available 510 if (false == ReadFPR()) 511 m_fpr_type = eFXSAVE; // assume generic floating-point registers 512} 513 514RegisterContext_x86_64::~RegisterContext_x86_64() 515{ 516} 517 518void 519RegisterContext_x86_64::Invalidate() 520{ 521} 522 523void 524RegisterContext_x86_64::InvalidateAllRegisters() 525{ 526} 527 528unsigned 529RegisterContext_x86_64::GetRegisterOffset(unsigned reg) 530{ 531 assert(reg < k_num_registers && "Invalid register number."); 532 return GetRegisterInfo()[reg].byte_offset; 533} 534 535unsigned 536RegisterContext_x86_64::GetRegisterSize(unsigned reg) 537{ 538 assert(reg < k_num_registers && "Invalid register number."); 539 return GetRegisterInfo()[reg].byte_size; 540} 541 542size_t 543RegisterContext_x86_64::GetRegisterCount() 544{ 545 size_t num_registers = k_num_gpr_registers + k_num_fpr_registers; 546 if (m_fpr_type == eXSAVE) 547 return num_registers + k_num_avx_registers; 548 return num_registers; 549} 550 551const RegisterInfo * 552RegisterContext_x86_64::GetRegisterInfo() 553{ 554 // Commonly, this method is overridden and g_register_infos is copied and specialized. 555 // So, use GetRegisterInfo() rather than g_register_infos in this scope. 556 return g_register_infos; 557} 558 559const RegisterInfo * 560RegisterContext_x86_64::GetRegisterInfoAtIndex(size_t reg) 561{ 562 if (reg < k_num_registers) 563 return &GetRegisterInfo()[reg]; 564 else 565 return NULL; 566} 567 568size_t 569RegisterContext_x86_64::GetRegisterSetCount() 570{ 571 size_t sets = 0; 572 for (size_t set = 0; set < k_num_register_sets; ++set) 573 if (IsRegisterSetAvailable(set)) 574 ++sets; 575 576 return sets; 577} 578 579const RegisterSet * 580RegisterContext_x86_64::GetRegisterSet(size_t set) 581{ 582 if (IsRegisterSetAvailable(set)) 583 return &g_reg_sets[set]; 584 else 585 return NULL; 586} 587 588unsigned 589RegisterContext_x86_64::GetRegisterIndexFromOffset(unsigned offset) 590{ 591 unsigned reg; 592 for (reg = 0; reg < k_num_registers; reg++) 593 { 594 if (GetRegisterInfo()[reg].byte_offset == offset) 595 break; 596 } 597 assert(reg < k_num_registers && "Invalid register offset."); 598 return reg; 599} 600 601const char * 602RegisterContext_x86_64::GetRegisterName(unsigned reg) 603{ 604 assert(reg < k_num_registers && "Invalid register offset."); 605 return GetRegisterInfo()[reg].name; 606} 607 608lldb::ByteOrder 609RegisterContext_x86_64::GetByteOrder() 610{ 611 // Get the target process whose privileged thread was used for the register read. 612 lldb::ByteOrder byte_order = eByteOrderInvalid; 613 Process *process = CalculateProcess().get(); 614 615 if (process) 616 byte_order = process->GetByteOrder(); 617 return byte_order; 618} 619 620// Parse ymm registers and into xmm.bytes and ymmh.bytes. 621bool RegisterContext_x86_64::CopyYMMtoXSTATE(uint32_t reg, lldb::ByteOrder byte_order) 622{ 623 if (!IsAVX(reg)) 624 return false; 625 626 if (byte_order == eByteOrderLittle) { 627 ::memcpy(m_fpr.xstate.fxsave.xmm[reg - fpu_ymm0].bytes, 628 m_ymm_set.ymm[reg - fpu_ymm0].bytes, 629 sizeof(RegisterContext_x86_64::XMMReg)); 630 ::memcpy(m_fpr.xstate.xsave.ymmh[reg - fpu_ymm0].bytes, 631 m_ymm_set.ymm[reg - fpu_ymm0].bytes + sizeof(RegisterContext_x86_64::XMMReg), 632 sizeof(RegisterContext_x86_64::YMMHReg)); 633 return true; 634 } 635 636 if (byte_order == eByteOrderBig) { 637 ::memcpy(m_fpr.xstate.fxsave.xmm[reg - fpu_ymm0].bytes, 638 m_ymm_set.ymm[reg - fpu_ymm0].bytes + sizeof(RegisterContext_x86_64::XMMReg), 639 sizeof(RegisterContext_x86_64::XMMReg)); 640 ::memcpy(m_fpr.xstate.xsave.ymmh[reg - fpu_ymm0].bytes, 641 m_ymm_set.ymm[reg - fpu_ymm0].bytes, 642 sizeof(RegisterContext_x86_64::YMMHReg)); 643 return true; 644 } 645 return false; // unsupported or invalid byte order 646} 647 648// Concatenate xmm.bytes with ymmh.bytes 649bool RegisterContext_x86_64::CopyXSTATEtoYMM(uint32_t reg, lldb::ByteOrder byte_order) 650{ 651 if (!IsAVX(reg)) 652 return false; 653 654 if (byte_order == eByteOrderLittle) { 655 ::memcpy(m_ymm_set.ymm[reg - fpu_ymm0].bytes, 656 m_fpr.xstate.fxsave.xmm[reg - fpu_ymm0].bytes, 657 sizeof(RegisterContext_x86_64::XMMReg)); 658 ::memcpy(m_ymm_set.ymm[reg - fpu_ymm0].bytes + sizeof(RegisterContext_x86_64::XMMReg), 659 m_fpr.xstate.xsave.ymmh[reg - fpu_ymm0].bytes, 660 sizeof(RegisterContext_x86_64::YMMHReg)); 661 return true; 662 } 663 if (byte_order == eByteOrderBig) { 664 ::memcpy(m_ymm_set.ymm[reg - fpu_ymm0].bytes + sizeof(RegisterContext_x86_64::XMMReg), 665 m_fpr.xstate.fxsave.xmm[reg - fpu_ymm0].bytes, 666 sizeof(RegisterContext_x86_64::XMMReg)); 667 ::memcpy(m_ymm_set.ymm[reg - fpu_ymm0].bytes, 668 m_fpr.xstate.xsave.ymmh[reg - fpu_ymm0].bytes, 669 sizeof(RegisterContext_x86_64::YMMHReg)); 670 return true; 671 } 672 return false; // unsupported or invalid byte order 673} 674 675bool 676RegisterContext_x86_64::IsRegisterSetAvailable(size_t set_index) 677{ 678 // Note: Extended register sets are assumed to be at the end of g_reg_sets... 679 size_t num_sets = k_num_register_sets - k_num_extended_register_sets; 680 if (m_fpr_type == eXSAVE) // ...and to start with AVX registers. 681 ++num_sets; 682 683 return (set_index < num_sets); 684} 685 686bool 687RegisterContext_x86_64::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value) 688{ 689 if (!reg_info) 690 return false; 691 692 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; 693 694 if (IsFPR(reg, m_fpr_type)) { 695 if (!ReadFPR()) 696 return false; 697 } 698 else { 699 bool success = ReadRegister(reg, value); 700 701 // If an i386 register should be parsed from an x86_64 register... 702 if (success && reg >= k_first_i386 && reg <= k_last_i386) 703 if (value.GetByteSize() > reg_info->byte_size) 704 value.SetType(reg_info); // ...use the type specified by reg_info rather than the uint64_t default 705 return success; 706 } 707 708 if (reg_info->encoding == eEncodingVector) { 709 ByteOrder byte_order = GetByteOrder(); 710 711 if (byte_order != ByteOrder::eByteOrderInvalid) { 712 if (reg >= fpu_stmm0 && reg <= fpu_stmm7) { 713 value.SetBytes(m_fpr.xstate.fxsave.stmm[reg - fpu_stmm0].bytes, reg_info->byte_size, byte_order); 714 } 715 if (reg >= fpu_xmm0 && reg <= fpu_xmm15) { 716 value.SetBytes(m_fpr.xstate.fxsave.xmm[reg - fpu_xmm0].bytes, reg_info->byte_size, byte_order); 717 } 718 if (reg >= fpu_ymm0 && reg <= fpu_ymm15) { 719 // Concatenate ymm using the register halves in xmm.bytes and ymmh.bytes 720 if (m_fpr_type == eXSAVE && CopyXSTATEtoYMM(reg, byte_order)) 721 value.SetBytes(m_ymm_set.ymm[reg - fpu_ymm0].bytes, reg_info->byte_size, byte_order); 722 else 723 return false; 724 } 725 return value.GetType() == RegisterValue::eTypeBytes; 726 } 727 return false; 728 } 729 730 // Note that lldb uses slightly different naming conventions from sys/user.h 731 switch (reg) 732 { 733 default: 734 return false; 735 case fpu_dp: 736 value = m_fpr.xstate.fxsave.dp; 737 break; 738 case fpu_fcw: 739 value = m_fpr.xstate.fxsave.fcw; 740 break; 741 case fpu_fsw: 742 value = m_fpr.xstate.fxsave.fsw; 743 break; 744 case fpu_ip: 745 value = m_fpr.xstate.fxsave.ip; 746 break; 747 case fpu_fop: 748 value = m_fpr.xstate.fxsave.fop; 749 break; 750 case fpu_ftw: 751 value = m_fpr.xstate.fxsave.ftw; 752 break; 753 case fpu_mxcsr: 754 value = m_fpr.xstate.fxsave.mxcsr; 755 break; 756 case fpu_mxcsrmask: 757 value = m_fpr.xstate.fxsave.mxcsrmask; 758 break; 759 } 760 return true; 761} 762 763bool 764RegisterContext_x86_64::ReadAllRegisterValues(DataBufferSP &data_sp) 765{ 766 bool success = false; 767 data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0)); 768 if (data_sp && ReadGPR () && ReadFPR ()) 769 { 770 uint8_t *dst = data_sp->GetBytes(); 771 success = dst != 0; 772 773 if (success) { 774 ::memcpy (dst, &m_gpr, GetGPRSize()); 775 dst += GetGPRSize(); 776 } 777 if (m_fpr_type == eFXSAVE) 778 ::memcpy (dst, &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave)); 779 780 if (m_fpr_type == eXSAVE) { 781 ByteOrder byte_order = GetByteOrder(); 782 783 // Assemble the YMM register content from the register halves. 784 for (uint32_t reg = fpu_ymm0; success && reg <= fpu_ymm15; ++reg) 785 success = CopyXSTATEtoYMM(reg, byte_order); 786 787 if (success) { 788 // Copy the extended register state including the assembled ymm registers. 789 ::memcpy (dst, &m_fpr, sizeof(m_fpr)); 790 } 791 } 792 } 793 return success; 794} 795 796bool 797RegisterContext_x86_64::WriteRegister(const lldb_private::RegisterInfo *reg_info, 798 const lldb_private::RegisterValue &value) 799{ 800 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; 801 if (IsGPR(reg)) { 802 return WriteRegister(reg, value); 803 } 804 805 if (IsFPR(reg, m_fpr_type)) { 806 switch (reg) 807 { 808 default: 809 if (reg_info->encoding != eEncodingVector) 810 return false; 811 812 if (reg >= fpu_stmm0 && reg <= fpu_stmm7) 813 ::memcpy (m_fpr.xstate.fxsave.stmm[reg - fpu_stmm0].bytes, value.GetBytes(), value.GetByteSize()); 814 815 if (reg >= fpu_xmm0 && reg <= fpu_xmm15) 816 ::memcpy (m_fpr.xstate.fxsave.xmm[reg - fpu_xmm0].bytes, value.GetBytes(), value.GetByteSize()); 817 818 if (reg >= fpu_ymm0 && reg <= fpu_ymm15) { 819 if (m_fpr_type != eXSAVE) 820 return false; // the target processor does not support AVX 821 822 // Store ymm register content, and split into the register halves in xmm.bytes and ymmh.bytes 823 ::memcpy (m_ymm_set.ymm[reg - fpu_ymm0].bytes, value.GetBytes(), value.GetByteSize()); 824 if (false == CopyYMMtoXSTATE(reg, GetByteOrder())) 825 return false; 826 } 827 break; 828 case fpu_dp: 829 m_fpr.xstate.fxsave.dp = value.GetAsUInt64(); 830 break; 831 case fpu_fcw: 832 m_fpr.xstate.fxsave.fcw = value.GetAsUInt16(); 833 break; 834 case fpu_fsw: 835 m_fpr.xstate.fxsave.fsw = value.GetAsUInt16(); 836 break; 837 case fpu_ip: 838 m_fpr.xstate.fxsave.ip = value.GetAsUInt64(); 839 break; 840 case fpu_fop: 841 m_fpr.xstate.fxsave.fop = value.GetAsUInt16(); 842 break; 843 case fpu_ftw: 844 m_fpr.xstate.fxsave.ftw = value.GetAsUInt16(); 845 break; 846 case fpu_mxcsr: 847 m_fpr.xstate.fxsave.mxcsr = value.GetAsUInt32(); 848 break; 849 case fpu_mxcsrmask: 850 m_fpr.xstate.fxsave.mxcsrmask = value.GetAsUInt32(); 851 break; 852 } 853 if (WriteFPR()) { 854 if (IsAVX(reg)) 855 return CopyYMMtoXSTATE(reg, GetByteOrder()); 856 return true; 857 } 858 } 859 return false; 860} 861 862bool 863RegisterContext_x86_64::WriteAllRegisterValues(const DataBufferSP &data_sp) 864{ 865 bool success = false; 866 if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) 867 { 868 uint8_t *src = data_sp->GetBytes(); 869 if (src) { 870 ::memcpy (&m_gpr, src, GetGPRSize()); 871 872 if (WriteGPR()) { 873 src += GetGPRSize(); 874 if (m_fpr_type == eFXSAVE) 875 ::memcpy (&m_fpr.xstate.fxsave, src, sizeof(m_fpr.xstate.fxsave)); 876 if (m_fpr_type == eXSAVE) 877 ::memcpy (&m_fpr.xstate.xsave, src, sizeof(m_fpr.xstate.xsave)); 878 879 success = WriteFPR(); 880 if (success) { 881 success = true; 882 883 if (m_fpr_type == eXSAVE) { 884 ByteOrder byte_order = GetByteOrder(); 885 886 // Parse the YMM register content from the register halves. 887 for (uint32_t reg = fpu_ymm0; success && reg <= fpu_ymm15; ++reg) 888 success = CopyYMMtoXSTATE(reg, byte_order); 889 } 890 } 891 } 892 } 893 } 894 return success; 895} 896 897bool 898RegisterContext_x86_64::UpdateAfterBreakpoint() 899{ 900 // PC points one byte past the int3 responsible for the breakpoint. 901 lldb::addr_t pc; 902 903 if ((pc = GetPC()) == LLDB_INVALID_ADDRESS) 904 return false; 905 906 SetPC(pc - 1); 907 return true; 908} 909 910uint32_t 911RegisterContext_x86_64::ConvertRegisterKindToRegisterNumber(uint32_t kind, 912 uint32_t num) 913{ 914 const Process *process = CalculateProcess().get(); 915 if (process) 916 { 917 const ArchSpec arch = process->GetTarget().GetArchitecture();; 918 switch (arch.GetCore()) 919 { 920 default: 921 assert(false && "CPU type not supported!"); 922 break; 923 924 case ArchSpec::eCore_x86_32_i386: 925 case ArchSpec::eCore_x86_32_i486: 926 case ArchSpec::eCore_x86_32_i486sx: 927 { 928 if (kind == eRegisterKindGeneric) 929 { 930 switch (num) 931 { 932 case LLDB_REGNUM_GENERIC_PC: return gpr_eip; 933 case LLDB_REGNUM_GENERIC_SP: return gpr_esp; 934 case LLDB_REGNUM_GENERIC_FP: return gpr_ebp; 935 case LLDB_REGNUM_GENERIC_FLAGS: return gpr_eflags; 936 case LLDB_REGNUM_GENERIC_RA: 937 default: 938 return LLDB_INVALID_REGNUM; 939 } 940 } 941 942 if (kind == eRegisterKindGCC || kind == eRegisterKindDWARF) 943 { 944 switch (num) 945 { 946 case dwarf_eax: return gpr_eax; 947 case dwarf_edx: return gpr_edx; 948 case dwarf_ecx: return gpr_ecx; 949 case dwarf_ebx: return gpr_ebx; 950 case dwarf_esi: return gpr_esi; 951 case dwarf_edi: return gpr_edi; 952 case dwarf_ebp: return gpr_ebp; 953 case dwarf_esp: return gpr_esp; 954 case dwarf_eip: return gpr_eip; 955 case dwarf_xmm0: return fpu_xmm0; 956 case dwarf_xmm1: return fpu_xmm1; 957 case dwarf_xmm2: return fpu_xmm2; 958 case dwarf_xmm3: return fpu_xmm3; 959 case dwarf_xmm4: return fpu_xmm4; 960 case dwarf_xmm5: return fpu_xmm5; 961 case dwarf_xmm6: return fpu_xmm6; 962 case dwarf_xmm7: return fpu_xmm7; 963 case dwarf_stmm0: return fpu_stmm0; 964 case dwarf_stmm1: return fpu_stmm1; 965 case dwarf_stmm2: return fpu_stmm2; 966 case dwarf_stmm3: return fpu_stmm3; 967 case dwarf_stmm4: return fpu_stmm4; 968 case dwarf_stmm5: return fpu_stmm5; 969 case dwarf_stmm6: return fpu_stmm6; 970 case dwarf_stmm7: return fpu_stmm7; 971 default: 972 return LLDB_INVALID_REGNUM; 973 } 974 } 975 976 if (kind == eRegisterKindGDB) 977 { 978 switch (num) 979 { 980 case gdb_eax : return gpr_eax; 981 case gdb_ebx : return gpr_ebx; 982 case gdb_ecx : return gpr_ecx; 983 case gdb_edx : return gpr_edx; 984 case gdb_esi : return gpr_esi; 985 case gdb_edi : return gpr_edi; 986 case gdb_ebp : return gpr_ebp; 987 case gdb_esp : return gpr_esp; 988 case gdb_eip : return gpr_eip; 989 case gdb_eflags : return gpr_eflags; 990 case gdb_cs : return gpr_cs; 991 case gdb_ss : return gpr_ss; 992 case gdb_ds : return gpr_ds; 993 case gdb_es : return gpr_es; 994 case gdb_fs : return gpr_fs; 995 case gdb_gs : return gpr_gs; 996 case gdb_stmm0 : return fpu_stmm0; 997 case gdb_stmm1 : return fpu_stmm1; 998 case gdb_stmm2 : return fpu_stmm2; 999 case gdb_stmm3 : return fpu_stmm3; 1000 case gdb_stmm4 : return fpu_stmm4; 1001 case gdb_stmm5 : return fpu_stmm5; 1002 case gdb_stmm6 : return fpu_stmm6; 1003 case gdb_stmm7 : return fpu_stmm7; 1004 case gdb_fcw : return fpu_fcw; 1005 case gdb_fsw : return fpu_fsw; 1006 case gdb_ftw : return fpu_ftw; 1007 case gdb_fpu_cs : return fpu_cs; 1008 case gdb_ip : return fpu_ip; 1009 case gdb_fpu_ds : return fpu_ds; //fpu_fos 1010 case gdb_dp : return fpu_dp; //fpu_foo 1011 case gdb_fop : return fpu_fop; 1012 case gdb_xmm0 : return fpu_xmm0; 1013 case gdb_xmm1 : return fpu_xmm1; 1014 case gdb_xmm2 : return fpu_xmm2; 1015 case gdb_xmm3 : return fpu_xmm3; 1016 case gdb_xmm4 : return fpu_xmm4; 1017 case gdb_xmm5 : return fpu_xmm5; 1018 case gdb_xmm6 : return fpu_xmm6; 1019 case gdb_xmm7 : return fpu_xmm7; 1020 case gdb_mxcsr : return fpu_mxcsr; 1021 default: 1022 return LLDB_INVALID_REGNUM; 1023 } 1024 } 1025 else if (kind == eRegisterKindLLDB) 1026 { 1027 return num; 1028 } 1029 1030 break; 1031 } 1032 1033 case ArchSpec::eCore_x86_64_x86_64: 1034 { 1035 if (kind == eRegisterKindGeneric) 1036 { 1037 switch (num) 1038 { 1039 case LLDB_REGNUM_GENERIC_PC: return gpr_rip; 1040 case LLDB_REGNUM_GENERIC_SP: return gpr_rsp; 1041 case LLDB_REGNUM_GENERIC_FP: return gpr_rbp; 1042 case LLDB_REGNUM_GENERIC_FLAGS: return gpr_rflags; 1043 case LLDB_REGNUM_GENERIC_RA: 1044 default: 1045 return LLDB_INVALID_REGNUM; 1046 } 1047 } 1048 1049 if (kind == eRegisterKindGCC || kind == eRegisterKindDWARF) 1050 { 1051 switch (num) 1052 { 1053 case gcc_dwarf_gpr_rax: return gpr_rax; 1054 case gcc_dwarf_gpr_rdx: return gpr_rdx; 1055 case gcc_dwarf_gpr_rcx: return gpr_rcx; 1056 case gcc_dwarf_gpr_rbx: return gpr_rbx; 1057 case gcc_dwarf_gpr_rsi: return gpr_rsi; 1058 case gcc_dwarf_gpr_rdi: return gpr_rdi; 1059 case gcc_dwarf_gpr_rbp: return gpr_rbp; 1060 case gcc_dwarf_gpr_rsp: return gpr_rsp; 1061 case gcc_dwarf_gpr_r8: return gpr_r8; 1062 case gcc_dwarf_gpr_r9: return gpr_r9; 1063 case gcc_dwarf_gpr_r10: return gpr_r10; 1064 case gcc_dwarf_gpr_r11: return gpr_r11; 1065 case gcc_dwarf_gpr_r12: return gpr_r12; 1066 case gcc_dwarf_gpr_r13: return gpr_r13; 1067 case gcc_dwarf_gpr_r14: return gpr_r14; 1068 case gcc_dwarf_gpr_r15: return gpr_r15; 1069 case gcc_dwarf_gpr_rip: return gpr_rip; 1070 case gcc_dwarf_fpu_xmm0: return fpu_xmm0; 1071 case gcc_dwarf_fpu_xmm1: return fpu_xmm1; 1072 case gcc_dwarf_fpu_xmm2: return fpu_xmm2; 1073 case gcc_dwarf_fpu_xmm3: return fpu_xmm3; 1074 case gcc_dwarf_fpu_xmm4: return fpu_xmm4; 1075 case gcc_dwarf_fpu_xmm5: return fpu_xmm5; 1076 case gcc_dwarf_fpu_xmm6: return fpu_xmm6; 1077 case gcc_dwarf_fpu_xmm7: return fpu_xmm7; 1078 case gcc_dwarf_fpu_xmm8: return fpu_xmm8; 1079 case gcc_dwarf_fpu_xmm9: return fpu_xmm9; 1080 case gcc_dwarf_fpu_xmm10: return fpu_xmm10; 1081 case gcc_dwarf_fpu_xmm11: return fpu_xmm11; 1082 case gcc_dwarf_fpu_xmm12: return fpu_xmm12; 1083 case gcc_dwarf_fpu_xmm13: return fpu_xmm13; 1084 case gcc_dwarf_fpu_xmm14: return fpu_xmm14; 1085 case gcc_dwarf_fpu_xmm15: return fpu_xmm15; 1086 case gcc_dwarf_fpu_stmm0: return fpu_stmm0; 1087 case gcc_dwarf_fpu_stmm1: return fpu_stmm1; 1088 case gcc_dwarf_fpu_stmm2: return fpu_stmm2; 1089 case gcc_dwarf_fpu_stmm3: return fpu_stmm3; 1090 case gcc_dwarf_fpu_stmm4: return fpu_stmm4; 1091 case gcc_dwarf_fpu_stmm5: return fpu_stmm5; 1092 case gcc_dwarf_fpu_stmm6: return fpu_stmm6; 1093 case gcc_dwarf_fpu_stmm7: return fpu_stmm7; 1094 case gcc_dwarf_fpu_ymm0: return fpu_ymm0; 1095 case gcc_dwarf_fpu_ymm1: return fpu_ymm1; 1096 case gcc_dwarf_fpu_ymm2: return fpu_ymm2; 1097 case gcc_dwarf_fpu_ymm3: return fpu_ymm3; 1098 case gcc_dwarf_fpu_ymm4: return fpu_ymm4; 1099 case gcc_dwarf_fpu_ymm5: return fpu_ymm5; 1100 case gcc_dwarf_fpu_ymm6: return fpu_ymm6; 1101 case gcc_dwarf_fpu_ymm7: return fpu_ymm7; 1102 case gcc_dwarf_fpu_ymm8: return fpu_ymm8; 1103 case gcc_dwarf_fpu_ymm9: return fpu_ymm9; 1104 case gcc_dwarf_fpu_ymm10: return fpu_ymm10; 1105 case gcc_dwarf_fpu_ymm11: return fpu_ymm11; 1106 case gcc_dwarf_fpu_ymm12: return fpu_ymm12; 1107 case gcc_dwarf_fpu_ymm13: return fpu_ymm13; 1108 case gcc_dwarf_fpu_ymm14: return fpu_ymm14; 1109 case gcc_dwarf_fpu_ymm15: return fpu_ymm15; 1110 default: 1111 return LLDB_INVALID_REGNUM; 1112 } 1113 } 1114 1115 if (kind == eRegisterKindGDB) 1116 { 1117 switch (num) 1118 { 1119 case gdb_gpr_rax : return gpr_rax; 1120 case gdb_gpr_rbx : return gpr_rbx; 1121 case gdb_gpr_rcx : return gpr_rcx; 1122 case gdb_gpr_rdx : return gpr_rdx; 1123 case gdb_gpr_rsi : return gpr_rsi; 1124 case gdb_gpr_rdi : return gpr_rdi; 1125 case gdb_gpr_rbp : return gpr_rbp; 1126 case gdb_gpr_rsp : return gpr_rsp; 1127 case gdb_gpr_r8 : return gpr_r8; 1128 case gdb_gpr_r9 : return gpr_r9; 1129 case gdb_gpr_r10 : return gpr_r10; 1130 case gdb_gpr_r11 : return gpr_r11; 1131 case gdb_gpr_r12 : return gpr_r12; 1132 case gdb_gpr_r13 : return gpr_r13; 1133 case gdb_gpr_r14 : return gpr_r14; 1134 case gdb_gpr_r15 : return gpr_r15; 1135 case gdb_gpr_rip : return gpr_rip; 1136 case gdb_gpr_rflags : return gpr_rflags; 1137 case gdb_gpr_cs : return gpr_cs; 1138 case gdb_gpr_ss : return gpr_ss; 1139 case gdb_gpr_ds : return gpr_ds; 1140 case gdb_gpr_es : return gpr_es; 1141 case gdb_gpr_fs : return gpr_fs; 1142 case gdb_gpr_gs : return gpr_gs; 1143 case gdb_fpu_stmm0 : return fpu_stmm0; 1144 case gdb_fpu_stmm1 : return fpu_stmm1; 1145 case gdb_fpu_stmm2 : return fpu_stmm2; 1146 case gdb_fpu_stmm3 : return fpu_stmm3; 1147 case gdb_fpu_stmm4 : return fpu_stmm4; 1148 case gdb_fpu_stmm5 : return fpu_stmm5; 1149 case gdb_fpu_stmm6 : return fpu_stmm6; 1150 case gdb_fpu_stmm7 : return fpu_stmm7; 1151 case gdb_fpu_fcw : return fpu_fcw; 1152 case gdb_fpu_fsw : return fpu_fsw; 1153 case gdb_fpu_ftw : return fpu_ftw; 1154 case gdb_fpu_cs_64 : return fpu_cs; 1155 case gdb_fpu_ip : return fpu_ip; 1156 case gdb_fpu_ds_64 : return fpu_ds; 1157 case gdb_fpu_dp : return fpu_dp; 1158 case gdb_fpu_fop : return fpu_fop; 1159 case gdb_fpu_xmm0 : return fpu_xmm0; 1160 case gdb_fpu_xmm1 : return fpu_xmm1; 1161 case gdb_fpu_xmm2 : return fpu_xmm2; 1162 case gdb_fpu_xmm3 : return fpu_xmm3; 1163 case gdb_fpu_xmm4 : return fpu_xmm4; 1164 case gdb_fpu_xmm5 : return fpu_xmm5; 1165 case gdb_fpu_xmm6 : return fpu_xmm6; 1166 case gdb_fpu_xmm7 : return fpu_xmm7; 1167 case gdb_fpu_xmm8 : return fpu_xmm8; 1168 case gdb_fpu_xmm9 : return fpu_xmm9; 1169 case gdb_fpu_xmm10 : return fpu_xmm10; 1170 case gdb_fpu_xmm11 : return fpu_xmm11; 1171 case gdb_fpu_xmm12 : return fpu_xmm12; 1172 case gdb_fpu_xmm13 : return fpu_xmm13; 1173 case gdb_fpu_xmm14 : return fpu_xmm14; 1174 case gdb_fpu_xmm15 : return fpu_xmm15; 1175 case gdb_fpu_mxcsr : return fpu_mxcsr; 1176 case gdb_fpu_ymm0 : return fpu_ymm0; 1177 case gdb_fpu_ymm1 : return fpu_ymm1; 1178 case gdb_fpu_ymm2 : return fpu_ymm2; 1179 case gdb_fpu_ymm3 : return fpu_ymm3; 1180 case gdb_fpu_ymm4 : return fpu_ymm4; 1181 case gdb_fpu_ymm5 : return fpu_ymm5; 1182 case gdb_fpu_ymm6 : return fpu_ymm6; 1183 case gdb_fpu_ymm7 : return fpu_ymm7; 1184 case gdb_fpu_ymm8 : return fpu_ymm8; 1185 case gdb_fpu_ymm9 : return fpu_ymm9; 1186 case gdb_fpu_ymm10 : return fpu_ymm10; 1187 case gdb_fpu_ymm11 : return fpu_ymm11; 1188 case gdb_fpu_ymm12 : return fpu_ymm12; 1189 case gdb_fpu_ymm13 : return fpu_ymm13; 1190 case gdb_fpu_ymm14 : return fpu_ymm14; 1191 case gdb_fpu_ymm15 : return fpu_ymm15; 1192 default: 1193 return LLDB_INVALID_REGNUM; 1194 } 1195 } 1196 else if (kind == eRegisterKindLLDB) 1197 { 1198 return num; 1199 } 1200 } 1201 } 1202 } 1203 1204 return LLDB_INVALID_REGNUM; 1205} 1206 1207uint32_t 1208RegisterContext_x86_64::NumSupportedHardwareWatchpoints() 1209{ 1210 // Available debug address registers: dr0, dr1, dr2, dr3 1211 return 4; 1212} 1213 1214bool 1215RegisterContext_x86_64::IsWatchpointVacant(uint32_t hw_index) 1216{ 1217 bool is_vacant = false; 1218 RegisterValue value; 1219 1220 assert(hw_index < NumSupportedHardwareWatchpoints()); 1221 1222 if (m_watchpoints_initialized == false) 1223 { 1224 // Reset the debug status and debug control registers 1225 RegisterValue zero_bits = RegisterValue(uint64_t(0)); 1226 if (!WriteRegister(dr6, zero_bits) || !WriteRegister(dr7, zero_bits)) 1227 assert(false && "Could not initialize watchpoint registers"); 1228 m_watchpoints_initialized = true; 1229 } 1230 1231 if (ReadRegister(dr7, value)) 1232 { 1233 uint64_t val = value.GetAsUInt64(); 1234 is_vacant = (val & (3 << 2*hw_index)) == 0; 1235 } 1236 1237 return is_vacant; 1238} 1239 1240static uint32_t 1241size_and_rw_bits(size_t size, bool read, bool write) 1242{ 1243 uint32_t rw; 1244 if (read) { 1245 rw = 0x3; // READ or READ/WRITE 1246 } else if (write) { 1247 rw = 0x1; // WRITE 1248 } else { 1249 assert(0 && "read and write cannot both be false"); 1250 } 1251 1252 switch (size) { 1253 case 1: 1254 return rw; 1255 case 2: 1256 return (0x1 << 2) | rw; 1257 case 4: 1258 return (0x3 << 2) | rw; 1259 case 8: 1260 return (0x2 << 2) | rw; 1261 default: 1262 assert(0 && "invalid size, must be one of 1, 2, 4, or 8"); 1263 } 1264} 1265 1266uint32_t 1267RegisterContext_x86_64::SetHardwareWatchpoint(addr_t addr, size_t size, 1268 bool read, bool write) 1269{ 1270 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints(); 1271 uint32_t hw_index; 1272 1273 for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) 1274 { 1275 if (IsWatchpointVacant(hw_index)) 1276 return SetHardwareWatchpointWithIndex(addr, size, 1277 read, write, 1278 hw_index); 1279 } 1280 1281 return LLDB_INVALID_INDEX32; 1282} 1283 1284bool 1285RegisterContext_x86_64::SetHardwareWatchpointWithIndex(addr_t addr, size_t size, 1286 bool read, bool write, 1287 uint32_t hw_index) 1288{ 1289 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints(); 1290 1291 if (num_hw_watchpoints == 0 || hw_index >= num_hw_watchpoints) 1292 return false; 1293 1294 if (!(size == 1 || size == 2 || size == 4 || size == 8)) 1295 return false; 1296 1297 if (read == false && write == false) 1298 return false; 1299 1300 if (!IsWatchpointVacant(hw_index)) 1301 return false; 1302 1303 // Set both dr7 (debug control register) and dri (debug address register). 1304 1305 // dr7{7-0} encodes the local/gloabl enable bits: 1306 // global enable --. .-- local enable 1307 // | | 1308 // v v 1309 // dr0 -> bits{1-0} 1310 // dr1 -> bits{3-2} 1311 // dr2 -> bits{5-4} 1312 // dr3 -> bits{7-6} 1313 // 1314 // dr7{31-16} encodes the rw/len bits: 1315 // b_x+3, b_x+2, b_x+1, b_x 1316 // where bits{x+1, x} => rw 1317 // 0b00: execute, 0b01: write, 0b11: read-or-write, 1318 // 0b10: io read-or-write (unused) 1319 // and bits{x+3, x+2} => len 1320 // 0b00: 1-byte, 0b01: 2-byte, 0b11: 4-byte, 0b10: 8-byte 1321 // 1322 // dr0 -> bits{19-16} 1323 // dr1 -> bits{23-20} 1324 // dr2 -> bits{27-24} 1325 // dr3 -> bits{31-28} 1326 if (hw_index < num_hw_watchpoints) 1327 { 1328 RegisterValue current_dr7_bits; 1329 1330 if (ReadRegister(dr7, current_dr7_bits)) 1331 { 1332 uint64_t new_dr7_bits = current_dr7_bits.GetAsUInt64() | 1333 (1 << (2*hw_index) | 1334 size_and_rw_bits(size, read, write) << 1335 (16+4*hw_index)); 1336 1337 if (WriteRegister(dr0 + hw_index, RegisterValue(addr)) && 1338 WriteRegister(dr7, RegisterValue(new_dr7_bits))) 1339 return true; 1340 } 1341 } 1342 1343 return false; 1344} 1345 1346bool 1347RegisterContext_x86_64::ClearHardwareWatchpoint(uint32_t hw_index) 1348{ 1349 if (hw_index < NumSupportedHardwareWatchpoints()) 1350 { 1351 RegisterValue current_dr7_bits; 1352 1353 if (ReadRegister(dr7, current_dr7_bits)) 1354 { 1355 uint64_t new_dr7_bits = current_dr7_bits.GetAsUInt64() & ~(3 << (2*hw_index)); 1356 1357 if (WriteRegister(dr7, RegisterValue(new_dr7_bits))) 1358 return true; 1359 } 1360 } 1361 1362 return false; 1363} 1364 1365bool 1366RegisterContext_x86_64::IsWatchpointHit(uint32_t hw_index) 1367{ 1368 bool is_hit = false; 1369 1370 if (m_watchpoints_initialized == false) 1371 { 1372 // Reset the debug status and debug control registers 1373 RegisterValue zero_bits = RegisterValue(uint64_t(0)); 1374 if (!WriteRegister(dr6, zero_bits) || !WriteRegister(dr7, zero_bits)) 1375 assert(false && "Could not initialize watchpoint registers"); 1376 m_watchpoints_initialized = true; 1377 } 1378 1379 if (hw_index < NumSupportedHardwareWatchpoints()) 1380 { 1381 RegisterValue value; 1382 1383 if (ReadRegister(dr6, value)) 1384 { 1385 uint64_t val = value.GetAsUInt64(); 1386 is_hit = val & (1 << hw_index); 1387 } 1388 } 1389 1390 return is_hit; 1391} 1392 1393addr_t 1394RegisterContext_x86_64::GetWatchpointAddress(uint32_t hw_index) 1395{ 1396 addr_t wp_monitor_addr = LLDB_INVALID_ADDRESS; 1397 1398 if (hw_index < NumSupportedHardwareWatchpoints()) 1399 { 1400 if (!IsWatchpointVacant(hw_index)) 1401 { 1402 RegisterValue value; 1403 1404 if (ReadRegister(dr0 + hw_index, value)) 1405 wp_monitor_addr = value.GetAsUInt64(); 1406 } 1407 } 1408 1409 return wp_monitor_addr; 1410} 1411 1412 1413bool 1414RegisterContext_x86_64::ClearWatchpointHits() 1415{ 1416 return WriteRegister(dr6, RegisterValue((uint64_t)0)); 1417} 1418 1419bool 1420RegisterContext_x86_64::HardwareSingleStep(bool enable) 1421{ 1422 enum { TRACE_BIT = 0x100 }; 1423 uint64_t rflags; 1424 1425 if ((rflags = ReadRegisterAsUnsigned(gpr_rflags, -1UL)) == -1UL) 1426 return false; 1427 1428 if (enable) 1429 { 1430 if (rflags & TRACE_BIT) 1431 return true; 1432 1433 rflags |= TRACE_BIT; 1434 } 1435 else 1436 { 1437 if (!(rflags & TRACE_BIT)) 1438 return false; 1439 1440 rflags &= ~TRACE_BIT; 1441 } 1442 1443 return WriteRegisterFromUnsigned(gpr_rflags, rflags); 1444} 1445 1446#if defined(__linux__) or defined(__FreeBSD__) 1447 1448ProcessMonitor & 1449RegisterContext_x86_64::GetMonitor() 1450{ 1451 ProcessSP base = CalculateProcess(); 1452 ProcessPOSIX *process = static_cast<ProcessPOSIX*>(base.get()); 1453 return process->GetMonitor(); 1454} 1455 1456bool 1457RegisterContext_x86_64::ReadGPR() 1458{ 1459 ProcessMonitor &monitor = GetMonitor(); 1460 return monitor.ReadGPR(m_thread.GetID(), &m_gpr, GetGPRSize()); 1461} 1462 1463bool 1464RegisterContext_x86_64::ReadFPR() 1465{ 1466 ProcessMonitor &monitor = GetMonitor(); 1467 if (m_fpr_type == eFXSAVE) 1468 return monitor.ReadFPR(m_thread.GetID(), &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave)); 1469 1470 if (m_fpr_type == eXSAVE) 1471 return monitor.ReadRegisterSet(m_thread.GetID(), &m_iovec, sizeof(m_fpr.xstate.xsave), NT_X86_XSTATE); 1472 return false; 1473} 1474 1475bool 1476RegisterContext_x86_64::WriteGPR() 1477{ 1478 ProcessMonitor &monitor = GetMonitor(); 1479 return monitor.WriteGPR(m_thread.GetID(), &m_gpr, GetGPRSize()); 1480} 1481 1482bool 1483RegisterContext_x86_64::WriteFPR() 1484{ 1485 ProcessMonitor &monitor = GetMonitor(); 1486 if (m_fpr_type == eFXSAVE) 1487 return monitor.WriteFPR(m_thread.GetID(), &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave)); 1488 1489 if (m_fpr_type == eXSAVE) 1490 return monitor.WriteRegisterSet(m_thread.GetID(), &m_iovec, sizeof(m_fpr.xstate.xsave), NT_X86_XSTATE); 1491 return false; 1492} 1493 1494bool 1495RegisterContext_x86_64::ReadRegister(const unsigned reg, 1496 RegisterValue &value) 1497{ 1498 ProcessMonitor &monitor = GetMonitor(); 1499 return monitor.ReadRegisterValue(m_thread.GetID(), 1500 GetRegisterOffset(reg), 1501 GetRegisterName(reg), 1502 GetRegisterSize(reg), 1503 value); 1504} 1505 1506bool 1507RegisterContext_x86_64::WriteRegister(const unsigned reg, 1508 const RegisterValue &value) 1509{ 1510 ProcessMonitor &monitor = GetMonitor(); 1511 return monitor.WriteRegisterValue(m_thread.GetID(), 1512 GetRegisterOffset(reg), 1513 GetRegisterName(reg), 1514 value); 1515} 1516 1517#else 1518 1519bool 1520RegisterContext_x86_64::ReadGPR() 1521{ 1522 llvm_unreachable("not implemented"); 1523 return false; 1524} 1525 1526bool 1527RegisterContext_x86_64::ReadFPR() 1528{ 1529 llvm_unreachable("not implemented"); 1530 return false; 1531} 1532 1533bool 1534RegisterContext_x86_64::WriteGPR() 1535{ 1536 llvm_unreachable("not implemented"); 1537 return false; 1538} 1539 1540bool 1541RegisterContext_x86_64::WriteFPR() 1542{ 1543 llvm_unreachable("not implemented"); 1544 return false; 1545} 1546 1547bool 1548RegisterContext_x86_64::ReadRegister(const unsigned reg, 1549 RegisterValue &value) 1550{ 1551 llvm_unreachable("not implemented"); 1552 return false; 1553} 1554 1555bool 1556RegisterContext_x86_64::WriteRegister(const unsigned reg, 1557 const RegisterValue &value) 1558{ 1559 llvm_unreachable("not implemented"); 1560 return false; 1561} 1562 1563#endif 1564