1 //===-- NativeRegisterContextLinux_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 "NativeRegisterContextLinux_x86_64.h" 11 12 #include "lldb/lldb-private-forward.h" 13 #include "lldb/Core/DataBufferHeap.h" 14 #include "lldb/Core/Error.h" 15 #include "lldb/Core/RegisterValue.h" 16 #include "lldb/Host/common/NativeProcessProtocol.h" 17 #include "lldb/Host/common/NativeThreadProtocol.h" 18 #include "Plugins/Process/Linux/NativeProcessLinux.h" 19 20 using namespace lldb_private; 21 22 // ---------------------------------------------------------------------------- 23 // Private namespace. 24 // ---------------------------------------------------------------------------- 25 26 namespace 27 { 28 // x86 32-bit general purpose registers. 29 const uint32_t 30 g_gpr_regnums_i386[] = 31 { 32 lldb_eax_i386, 33 lldb_ebx_i386, 34 lldb_ecx_i386, 35 lldb_edx_i386, 36 lldb_edi_i386, 37 lldb_esi_i386, 38 lldb_ebp_i386, 39 lldb_esp_i386, 40 lldb_eip_i386, 41 lldb_eflags_i386, 42 lldb_cs_i386, 43 lldb_fs_i386, 44 lldb_gs_i386, 45 lldb_ss_i386, 46 lldb_ds_i386, 47 lldb_es_i386, 48 lldb_ax_i386, 49 lldb_bx_i386, 50 lldb_cx_i386, 51 lldb_dx_i386, 52 lldb_di_i386, 53 lldb_si_i386, 54 lldb_bp_i386, 55 lldb_sp_i386, 56 lldb_ah_i386, 57 lldb_bh_i386, 58 lldb_ch_i386, 59 lldb_dh_i386, 60 lldb_al_i386, 61 lldb_bl_i386, 62 lldb_cl_i386, 63 lldb_dl_i386, 64 LLDB_INVALID_REGNUM // register sets need to end with this flag 65 }; 66 static_assert((sizeof(g_gpr_regnums_i386) / sizeof(g_gpr_regnums_i386[0])) - 1 == k_num_gpr_registers_i386, 67 "g_gpr_regnums_i386 has wrong number of register infos"); 68 69 // x86 32-bit floating point registers. 70 const uint32_t 71 g_fpu_regnums_i386[] = 72 { 73 lldb_fctrl_i386, 74 lldb_fstat_i386, 75 lldb_ftag_i386, 76 lldb_fop_i386, 77 lldb_fiseg_i386, 78 lldb_fioff_i386, 79 lldb_foseg_i386, 80 lldb_fooff_i386, 81 lldb_mxcsr_i386, 82 lldb_mxcsrmask_i386, 83 lldb_st0_i386, 84 lldb_st1_i386, 85 lldb_st2_i386, 86 lldb_st3_i386, 87 lldb_st4_i386, 88 lldb_st5_i386, 89 lldb_st6_i386, 90 lldb_st7_i386, 91 lldb_mm0_i386, 92 lldb_mm1_i386, 93 lldb_mm2_i386, 94 lldb_mm3_i386, 95 lldb_mm4_i386, 96 lldb_mm5_i386, 97 lldb_mm6_i386, 98 lldb_mm7_i386, 99 lldb_xmm0_i386, 100 lldb_xmm1_i386, 101 lldb_xmm2_i386, 102 lldb_xmm3_i386, 103 lldb_xmm4_i386, 104 lldb_xmm5_i386, 105 lldb_xmm6_i386, 106 lldb_xmm7_i386, 107 LLDB_INVALID_REGNUM // register sets need to end with this flag 108 }; 109 static_assert((sizeof(g_fpu_regnums_i386) / sizeof(g_fpu_regnums_i386[0])) - 1 == k_num_fpr_registers_i386, 110 "g_fpu_regnums_i386 has wrong number of register infos"); 111 112 // x86 32-bit AVX registers. 113 const uint32_t 114 g_avx_regnums_i386[] = 115 { 116 lldb_ymm0_i386, 117 lldb_ymm1_i386, 118 lldb_ymm2_i386, 119 lldb_ymm3_i386, 120 lldb_ymm4_i386, 121 lldb_ymm5_i386, 122 lldb_ymm6_i386, 123 lldb_ymm7_i386, 124 LLDB_INVALID_REGNUM // register sets need to end with this flag 125 }; 126 static_assert((sizeof(g_avx_regnums_i386) / sizeof(g_avx_regnums_i386[0])) - 1 == k_num_avx_registers_i386, 127 " g_avx_regnums_i386 has wrong number of register infos"); 128 129 // x86 64-bit general purpose registers. 130 static const 131 uint32_t g_gpr_regnums_x86_64[] = 132 { 133 lldb_rax_x86_64, 134 lldb_rbx_x86_64, 135 lldb_rcx_x86_64, 136 lldb_rdx_x86_64, 137 lldb_rdi_x86_64, 138 lldb_rsi_x86_64, 139 lldb_rbp_x86_64, 140 lldb_rsp_x86_64, 141 lldb_r8_x86_64, 142 lldb_r9_x86_64, 143 lldb_r10_x86_64, 144 lldb_r11_x86_64, 145 lldb_r12_x86_64, 146 lldb_r13_x86_64, 147 lldb_r14_x86_64, 148 lldb_r15_x86_64, 149 lldb_rip_x86_64, 150 lldb_rflags_x86_64, 151 lldb_cs_x86_64, 152 lldb_fs_x86_64, 153 lldb_gs_x86_64, 154 lldb_ss_x86_64, 155 lldb_ds_x86_64, 156 lldb_es_x86_64, 157 lldb_eax_x86_64, 158 lldb_ebx_x86_64, 159 lldb_ecx_x86_64, 160 lldb_edx_x86_64, 161 lldb_edi_x86_64, 162 lldb_esi_x86_64, 163 lldb_ebp_x86_64, 164 lldb_esp_x86_64, 165 lldb_r8d_x86_64, // Low 32 bits or r8 166 lldb_r9d_x86_64, // Low 32 bits or r9 167 lldb_r10d_x86_64, // Low 32 bits or r10 168 lldb_r11d_x86_64, // Low 32 bits or r11 169 lldb_r12d_x86_64, // Low 32 bits or r12 170 lldb_r13d_x86_64, // Low 32 bits or r13 171 lldb_r14d_x86_64, // Low 32 bits or r14 172 lldb_r15d_x86_64, // Low 32 bits or r15 173 lldb_ax_x86_64, 174 lldb_bx_x86_64, 175 lldb_cx_x86_64, 176 lldb_dx_x86_64, 177 lldb_di_x86_64, 178 lldb_si_x86_64, 179 lldb_bp_x86_64, 180 lldb_sp_x86_64, 181 lldb_r8w_x86_64, // Low 16 bits or r8 182 lldb_r9w_x86_64, // Low 16 bits or r9 183 lldb_r10w_x86_64, // Low 16 bits or r10 184 lldb_r11w_x86_64, // Low 16 bits or r11 185 lldb_r12w_x86_64, // Low 16 bits or r12 186 lldb_r13w_x86_64, // Low 16 bits or r13 187 lldb_r14w_x86_64, // Low 16 bits or r14 188 lldb_r15w_x86_64, // Low 16 bits or r15 189 lldb_ah_x86_64, 190 lldb_bh_x86_64, 191 lldb_ch_x86_64, 192 lldb_dh_x86_64, 193 lldb_al_x86_64, 194 lldb_bl_x86_64, 195 lldb_cl_x86_64, 196 lldb_dl_x86_64, 197 lldb_dil_x86_64, 198 lldb_sil_x86_64, 199 lldb_bpl_x86_64, 200 lldb_spl_x86_64, 201 lldb_r8l_x86_64, // Low 8 bits or r8 202 lldb_r9l_x86_64, // Low 8 bits or r9 203 lldb_r10l_x86_64, // Low 8 bits or r10 204 lldb_r11l_x86_64, // Low 8 bits or r11 205 lldb_r12l_x86_64, // Low 8 bits or r12 206 lldb_r13l_x86_64, // Low 8 bits or r13 207 lldb_r14l_x86_64, // Low 8 bits or r14 208 lldb_r15l_x86_64, // Low 8 bits or r15 209 LLDB_INVALID_REGNUM // register sets need to end with this flag 210 }; 211 static_assert((sizeof(g_gpr_regnums_x86_64) / sizeof(g_gpr_regnums_x86_64[0])) - 1 == k_num_gpr_registers_x86_64, 212 "g_gpr_regnums_x86_64 has wrong number of register infos"); 213 214 // x86 64-bit floating point registers. 215 static const uint32_t 216 g_fpu_regnums_x86_64[] = 217 { 218 lldb_fctrl_x86_64, 219 lldb_fstat_x86_64, 220 lldb_ftag_x86_64, 221 lldb_fop_x86_64, 222 lldb_fiseg_x86_64, 223 lldb_fioff_x86_64, 224 lldb_foseg_x86_64, 225 lldb_fooff_x86_64, 226 lldb_mxcsr_x86_64, 227 lldb_mxcsrmask_x86_64, 228 lldb_st0_x86_64, 229 lldb_st1_x86_64, 230 lldb_st2_x86_64, 231 lldb_st3_x86_64, 232 lldb_st4_x86_64, 233 lldb_st5_x86_64, 234 lldb_st6_x86_64, 235 lldb_st7_x86_64, 236 lldb_mm0_x86_64, 237 lldb_mm1_x86_64, 238 lldb_mm2_x86_64, 239 lldb_mm3_x86_64, 240 lldb_mm4_x86_64, 241 lldb_mm5_x86_64, 242 lldb_mm6_x86_64, 243 lldb_mm7_x86_64, 244 lldb_xmm0_x86_64, 245 lldb_xmm1_x86_64, 246 lldb_xmm2_x86_64, 247 lldb_xmm3_x86_64, 248 lldb_xmm4_x86_64, 249 lldb_xmm5_x86_64, 250 lldb_xmm6_x86_64, 251 lldb_xmm7_x86_64, 252 lldb_xmm8_x86_64, 253 lldb_xmm9_x86_64, 254 lldb_xmm10_x86_64, 255 lldb_xmm11_x86_64, 256 lldb_xmm12_x86_64, 257 lldb_xmm13_x86_64, 258 lldb_xmm14_x86_64, 259 lldb_xmm15_x86_64, 260 LLDB_INVALID_REGNUM // register sets need to end with this flag 261 }; 262 static_assert((sizeof(g_fpu_regnums_x86_64) / sizeof(g_fpu_regnums_x86_64[0])) - 1 == k_num_fpr_registers_x86_64, 263 "g_fpu_regnums_x86_64 has wrong number of register infos"); 264 265 // x86 64-bit AVX registers. 266 static const uint32_t 267 g_avx_regnums_x86_64[] = 268 { 269 lldb_ymm0_x86_64, 270 lldb_ymm1_x86_64, 271 lldb_ymm2_x86_64, 272 lldb_ymm3_x86_64, 273 lldb_ymm4_x86_64, 274 lldb_ymm5_x86_64, 275 lldb_ymm6_x86_64, 276 lldb_ymm7_x86_64, 277 lldb_ymm8_x86_64, 278 lldb_ymm9_x86_64, 279 lldb_ymm10_x86_64, 280 lldb_ymm11_x86_64, 281 lldb_ymm12_x86_64, 282 lldb_ymm13_x86_64, 283 lldb_ymm14_x86_64, 284 lldb_ymm15_x86_64, 285 LLDB_INVALID_REGNUM // register sets need to end with this flag 286 }; 287 static_assert((sizeof(g_avx_regnums_x86_64) / sizeof(g_avx_regnums_x86_64[0])) - 1 == k_num_avx_registers_x86_64, 288 "g_avx_regnums_x86_64 has wrong number of register infos"); 289 290 // Number of register sets provided by this context. 291 enum 292 { 293 k_num_extended_register_sets = 1, 294 k_num_register_sets = 3 295 }; 296 297 // Register sets for x86 32-bit. 298 static const RegisterSet 299 g_reg_sets_i386[k_num_register_sets] = 300 { 301 { "General Purpose Registers", "gpr", k_num_gpr_registers_i386, g_gpr_regnums_i386 }, 302 { "Floating Point Registers", "fpu", k_num_fpr_registers_i386, g_fpu_regnums_i386 }, 303 { "Advanced Vector Extensions", "avx", k_num_avx_registers_i386, g_avx_regnums_i386 } 304 }; 305 306 // Register sets for x86 64-bit. 307 static const RegisterSet 308 g_reg_sets_x86_64[k_num_register_sets] = 309 { 310 { "General Purpose Registers", "gpr", k_num_gpr_registers_x86_64, g_gpr_regnums_x86_64 }, 311 { "Floating Point Registers", "fpu", k_num_fpr_registers_x86_64, g_fpu_regnums_x86_64 }, 312 { "Advanced Vector Extensions", "avx", k_num_avx_registers_x86_64, g_avx_regnums_x86_64 } 313 }; 314 } 315 316 #define REG_CONTEXT_SIZE (GetRegisterInfoInterface ().GetGPRSize () + sizeof(FPR)) 317 318 // ---------------------------------------------------------------------------- 319 // Required ptrace defines. 320 // ---------------------------------------------------------------------------- 321 322 // Support ptrace extensions even when compiled without required kernel support 323 #ifndef NT_X86_XSTATE 324 #define NT_X86_XSTATE 0x202 325 #endif 326 327 // ---------------------------------------------------------------------------- 328 // NativeRegisterContextLinux_x86_64 members. 329 // ---------------------------------------------------------------------------- 330 331 NativeRegisterContextLinux_x86_64::NativeRegisterContextLinux_x86_64 (NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx, RegisterInfoInterface *reg_info_interface_p) : 332 NativeRegisterContextRegisterInfo (native_thread, concrete_frame_idx, reg_info_interface_p), 333 m_fpr_type (eFPRTypeNotValid), 334 m_fpr (), 335 m_iovec (), 336 m_ymm_set (), 337 m_reg_info (), 338 m_gpr_x86_64 () 339 { 340 // Set up data about ranges of valid registers. 341 switch (reg_info_interface_p->GetTargetArchitecture ().GetMachine ()) 342 { 343 case llvm::Triple::x86: 344 m_reg_info.num_registers = k_num_registers_i386; 345 m_reg_info.num_gpr_registers = k_num_gpr_registers_i386; 346 m_reg_info.num_fpr_registers = k_num_fpr_registers_i386; 347 m_reg_info.num_avx_registers = k_num_avx_registers_i386; 348 m_reg_info.last_gpr = k_last_gpr_i386; 349 m_reg_info.first_fpr = k_first_fpr_i386; 350 m_reg_info.last_fpr = k_last_fpr_i386; 351 m_reg_info.first_st = lldb_st0_i386; 352 m_reg_info.last_st = lldb_st7_i386; 353 m_reg_info.first_mm = lldb_mm0_i386; 354 m_reg_info.last_mm = lldb_mm7_i386; 355 m_reg_info.first_xmm = lldb_xmm0_i386; 356 m_reg_info.last_xmm = lldb_xmm7_i386; 357 m_reg_info.first_ymm = lldb_ymm0_i386; 358 m_reg_info.last_ymm = lldb_ymm7_i386; 359 m_reg_info.first_dr = lldb_dr0_i386; 360 m_reg_info.gpr_flags = lldb_eflags_i386; 361 break; 362 case llvm::Triple::x86_64: 363 m_reg_info.num_registers = k_num_registers_x86_64; 364 m_reg_info.num_gpr_registers = k_num_gpr_registers_x86_64; 365 m_reg_info.num_fpr_registers = k_num_fpr_registers_x86_64; 366 m_reg_info.num_avx_registers = k_num_avx_registers_x86_64; 367 m_reg_info.last_gpr = k_last_gpr_x86_64; 368 m_reg_info.first_fpr = k_first_fpr_x86_64; 369 m_reg_info.last_fpr = k_last_fpr_x86_64; 370 m_reg_info.first_st = lldb_st0_x86_64; 371 m_reg_info.last_st = lldb_st7_x86_64; 372 m_reg_info.first_mm = lldb_mm0_x86_64; 373 m_reg_info.last_mm = lldb_mm7_x86_64; 374 m_reg_info.first_xmm = lldb_xmm0_x86_64; 375 m_reg_info.last_xmm = lldb_xmm15_x86_64; 376 m_reg_info.first_ymm = lldb_ymm0_x86_64; 377 m_reg_info.last_ymm = lldb_ymm15_x86_64; 378 m_reg_info.first_dr = lldb_dr0_x86_64; 379 m_reg_info.gpr_flags = lldb_rflags_x86_64; 380 break; 381 default: 382 assert(false && "Unhandled target architecture."); 383 break; 384 } 385 386 // Initialize m_iovec to point to the buffer and buffer size 387 // using the conventions of Berkeley style UIO structures, as required 388 // by PTRACE extensions. 389 m_iovec.iov_base = &m_fpr.xstate.xsave; 390 m_iovec.iov_len = sizeof(m_fpr.xstate.xsave); 391 392 // Clear out the FPR state. 393 ::memset(&m_fpr, 0, sizeof(FPR)); 394 } 395 396 // CONSIDER after local and llgs debugging are merged, register set support can 397 // be moved into a base x86-64 class with IsRegisterSetAvailable made virtual. 398 uint32_t 399 NativeRegisterContextLinux_x86_64::GetRegisterSetCount () const 400 { 401 uint32_t sets = 0; 402 for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index) 403 { 404 if (IsRegisterSetAvailable (set_index)) 405 ++sets; 406 } 407 408 return sets; 409 } 410 411 const lldb_private::RegisterSet * 412 NativeRegisterContextLinux_x86_64::GetRegisterSet (uint32_t set_index) const 413 { 414 if (!IsRegisterSetAvailable (set_index)) 415 return nullptr; 416 417 switch (GetRegisterInfoInterface ().GetTargetArchitecture ().GetMachine ()) 418 { 419 case llvm::Triple::x86: 420 return &g_reg_sets_i386[set_index]; 421 case llvm::Triple::x86_64: 422 return &g_reg_sets_x86_64[set_index]; 423 default: 424 assert (false && "Unhandled target architecture."); 425 return nullptr; 426 } 427 428 return nullptr; 429 } 430 431 lldb_private::Error 432 NativeRegisterContextLinux_x86_64::ReadRegisterRaw (uint32_t reg_index, RegisterValue ®_value) 433 { 434 Error error; 435 const RegisterInfo *const reg_info = GetRegisterInfoAtIndex (reg_index); 436 if (!reg_info) 437 { 438 error.SetErrorStringWithFormat ("register %" PRIu32 " not found", reg_index); 439 return error; 440 } 441 442 NativeProcessProtocolSP process_sp (m_thread.GetProcess ()); 443 if (!process_sp) 444 { 445 error.SetErrorString ("NativeProcessProtocol is NULL"); 446 return error; 447 } 448 449 NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ()); 450 return process_p->ReadRegisterValue(m_thread.GetID(), 451 reg_info->byte_offset, 452 reg_info->name, 453 reg_info->byte_size, 454 reg_value); 455 } 456 457 lldb_private::Error 458 NativeRegisterContextLinux_x86_64::ReadRegister (const RegisterInfo *reg_info, RegisterValue ®_value) 459 { 460 Error error; 461 462 if (!reg_info) 463 { 464 error.SetErrorString ("reg_info NULL"); 465 return error; 466 } 467 468 const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB]; 469 if (reg == LLDB_INVALID_REGNUM) 470 { 471 // This is likely an internal register for lldb use only and should not be directly queried. 472 error.SetErrorStringWithFormat ("register \"%s\" is an internal-only lldb register, cannot read directly", reg_info->name); 473 return error; 474 } 475 476 if (IsFPR(reg, GetFPRType())) 477 { 478 if (!ReadFPR()) 479 { 480 error.SetErrorString ("failed to read floating point register"); 481 return error; 482 } 483 } 484 else 485 { 486 uint32_t full_reg = reg; 487 bool is_subreg = reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM); 488 489 if (is_subreg) 490 { 491 // Read the full aligned 64-bit register. 492 full_reg = reg_info->invalidate_regs[0]; 493 } 494 495 error = ReadRegisterRaw(full_reg, reg_value); 496 497 if (error.Success ()) 498 { 499 // If our read was not aligned (for ah,bh,ch,dh), shift our returned value one byte to the right. 500 if (is_subreg && (reg_info->byte_offset & 0x1)) 501 reg_value.SetUInt64(reg_value.GetAsUInt64() >> 8); 502 503 // If our return byte size was greater than the return value reg size, then 504 // use the type specified by reg_info rather than the uint64_t default 505 if (reg_value.GetByteSize() > reg_info->byte_size) 506 reg_value.SetType(reg_info); 507 } 508 return error; 509 } 510 511 if (reg_info->encoding == lldb::eEncodingVector) 512 { 513 lldb::ByteOrder byte_order = GetByteOrder(); 514 515 if (byte_order != lldb::eByteOrderInvalid) 516 { 517 if (reg >= m_reg_info.first_st && reg <= m_reg_info.last_st) 518 reg_value.SetBytes(m_fpr.xstate.fxsave.stmm[reg - m_reg_info.first_st].bytes, reg_info->byte_size, byte_order); 519 if (reg >= m_reg_info.first_mm && reg <= m_reg_info.last_mm) 520 reg_value.SetBytes(m_fpr.xstate.fxsave.stmm[reg - m_reg_info.first_mm].bytes, reg_info->byte_size, byte_order); 521 if (reg >= m_reg_info.first_xmm && reg <= m_reg_info.last_xmm) 522 reg_value.SetBytes(m_fpr.xstate.fxsave.xmm[reg - m_reg_info.first_xmm].bytes, reg_info->byte_size, byte_order); 523 if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) 524 { 525 // Concatenate ymm using the register halves in xmm.bytes and ymmh.bytes 526 if (GetFPRType() == eFPRTypeXSAVE && CopyXSTATEtoYMM(reg, byte_order)) 527 reg_value.SetBytes(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes, reg_info->byte_size, byte_order); 528 else 529 { 530 error.SetErrorString ("failed to copy ymm register value"); 531 return error; 532 } 533 } 534 535 if (reg_value.GetType() != RegisterValue::eTypeBytes) 536 error.SetErrorString ("write failed - type was expected to be RegisterValue::eTypeBytes"); 537 538 return error; 539 } 540 541 error.SetErrorString ("byte order is invalid"); 542 return error; 543 } 544 545 // Get pointer to m_fpr.xstate.fxsave variable and set the data from it. 546 assert (reg_info->byte_offset < sizeof(m_fpr)); 547 uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset; 548 switch (reg_info->byte_size) 549 { 550 case 2: 551 reg_value.SetUInt16(*(uint16_t *)src); 552 break; 553 case 4: 554 reg_value.SetUInt32(*(uint32_t *)src); 555 break; 556 case 8: 557 reg_value.SetUInt64(*(uint64_t *)src); 558 break; 559 default: 560 assert(false && "Unhandled data size."); 561 error.SetErrorStringWithFormat ("unhandled byte size: %" PRIu32, reg_info->byte_size); 562 break; 563 } 564 565 return error; 566 } 567 568 lldb_private::Error 569 NativeRegisterContextLinux_x86_64::WriteRegister(const uint32_t reg, 570 const RegisterValue &value) 571 { 572 Error error; 573 574 uint32_t reg_to_write = reg; 575 RegisterValue value_to_write = value; 576 577 // Check if this is a subregister of a full register. 578 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 579 if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) 580 { 581 RegisterValue full_value; 582 uint32_t full_reg = reg_info->invalidate_regs[0]; 583 const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg); 584 585 // Read the full register. 586 error = ReadRegister(full_reg_info, full_value); 587 if (error.Fail ()) 588 return error; 589 590 lldb::ByteOrder byte_order = GetByteOrder(); 591 uint8_t dst[RegisterValue::kMaxRegisterByteSize]; 592 593 // Get the bytes for the full register. 594 const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info, 595 dst, 596 sizeof(dst), 597 byte_order, 598 error); 599 if (error.Success() && dest_size) 600 { 601 uint8_t src[RegisterValue::kMaxRegisterByteSize]; 602 603 // Get the bytes for the source data. 604 const uint32_t src_size = value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error); 605 if (error.Success() && src_size && (src_size < dest_size)) 606 { 607 // Copy the src bytes to the destination. 608 memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size); 609 // Set this full register as the value to write. 610 value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order); 611 value_to_write.SetType(full_reg_info); 612 reg_to_write = full_reg; 613 } 614 } 615 } 616 617 618 NativeProcessProtocolSP process_sp (m_thread.GetProcess ()); 619 if (!process_sp) 620 { 621 error.SetErrorString ("NativeProcessProtocol is NULL"); 622 return error; 623 } 624 625 const RegisterInfo *const register_to_write_info_p = GetRegisterInfoAtIndex (reg_to_write); 626 assert (register_to_write_info_p && "register to write does not have valid RegisterInfo"); 627 if (!register_to_write_info_p) 628 { 629 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s failed to get RegisterInfo for write register index %" PRIu32, __FUNCTION__, reg_to_write); 630 return error; 631 } 632 633 NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ()); 634 return process_p->WriteRegisterValue(m_thread.GetID(), 635 register_to_write_info_p->byte_offset, 636 register_to_write_info_p->name, 637 value_to_write); 638 } 639 640 lldb_private::Error 641 NativeRegisterContextLinux_x86_64::WriteRegister (const RegisterInfo *reg_info, const RegisterValue ®_value) 642 { 643 assert (reg_info && "reg_info is null"); 644 645 const uint32_t reg_index = reg_info->kinds[lldb::eRegisterKindLLDB]; 646 if (reg_index == LLDB_INVALID_REGNUM) 647 return Error ("no lldb regnum for %s", reg_info && reg_info->name ? reg_info->name : "<unknown register>"); 648 649 if (IsGPR(reg_index)) 650 return WriteRegister(reg_index, reg_value); 651 652 if (IsFPR(reg_index, GetFPRType())) 653 { 654 if (reg_info->encoding == lldb::eEncodingVector) 655 { 656 if (reg_index >= m_reg_info.first_st && reg_index <= m_reg_info.last_st) 657 ::memcpy (m_fpr.xstate.fxsave.stmm[reg_index - m_reg_info.first_st].bytes, reg_value.GetBytes(), reg_value.GetByteSize()); 658 659 if (reg_index >= m_reg_info.first_mm && reg_index <= m_reg_info.last_mm) 660 ::memcpy (m_fpr.xstate.fxsave.stmm[reg_index - m_reg_info.first_mm].bytes, reg_value.GetBytes(), reg_value.GetByteSize()); 661 662 if (reg_index >= m_reg_info.first_xmm && reg_index <= m_reg_info.last_xmm) 663 ::memcpy (m_fpr.xstate.fxsave.xmm[reg_index - m_reg_info.first_xmm].bytes, reg_value.GetBytes(), reg_value.GetByteSize()); 664 665 if (reg_index >= m_reg_info.first_ymm && reg_index <= m_reg_info.last_ymm) 666 { 667 if (GetFPRType() != eFPRTypeXSAVE) 668 return Error ("target processor does not support AVX"); 669 670 // Store ymm register content, and split into the register halves in xmm.bytes and ymmh.bytes 671 ::memcpy (m_ymm_set.ymm[reg_index - m_reg_info.first_ymm].bytes, reg_value.GetBytes(), reg_value.GetByteSize()); 672 if (!CopyYMMtoXSTATE(reg_index, GetByteOrder())) 673 return Error ("CopyYMMtoXSTATE() failed"); 674 } 675 } 676 else 677 { 678 // Get pointer to m_fpr.xstate.fxsave variable and set the data to it. 679 assert (reg_info->byte_offset < sizeof(m_fpr)); 680 uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset; 681 switch (reg_info->byte_size) 682 { 683 case 2: 684 *(uint16_t *)dst = reg_value.GetAsUInt16(); 685 break; 686 case 4: 687 *(uint32_t *)dst = reg_value.GetAsUInt32(); 688 break; 689 case 8: 690 *(uint64_t *)dst = reg_value.GetAsUInt64(); 691 break; 692 default: 693 assert(false && "Unhandled data size."); 694 return Error ("unhandled register data size %" PRIu32, reg_info->byte_size); 695 } 696 } 697 698 if (WriteFPR()) 699 { 700 if (IsAVX(reg_index)) 701 { 702 if (!CopyYMMtoXSTATE(reg_index, GetByteOrder())) 703 return Error ("CopyYMMtoXSTATE() failed"); 704 } 705 return Error (); 706 } 707 } 708 return Error ("failed - register wasn't recognized to be a GPR or an FPR, write strategy unknown"); 709 } 710 711 lldb_private::Error 712 NativeRegisterContextLinux_x86_64::ReadAllRegisterValues (lldb::DataBufferSP &data_sp) 713 { 714 Error error; 715 716 data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0)); 717 if (!data_sp) 718 { 719 error.SetErrorStringWithFormat ("failed to allocate DataBufferHeap instance of size %" PRIu64, REG_CONTEXT_SIZE); 720 return error; 721 } 722 723 if (!ReadGPR ()) 724 { 725 error.SetErrorString ("ReadGPR() failed"); 726 return error; 727 } 728 729 if (!ReadFPR ()) 730 { 731 error.SetErrorString ("ReadFPR() failed"); 732 return error; 733 } 734 735 uint8_t *dst = data_sp->GetBytes (); 736 if (dst == nullptr) 737 { 738 error.SetErrorStringWithFormat ("DataBufferHeap instance of size %" PRIu64 " returned a null pointer", REG_CONTEXT_SIZE); 739 return error; 740 } 741 742 ::memcpy (dst, &m_gpr_x86_64, GetRegisterInfoInterface ().GetGPRSize ()); 743 dst += GetRegisterInfoInterface ().GetGPRSize (); 744 if (GetFPRType () == eFPRTypeFXSAVE) 745 ::memcpy (dst, &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave)); 746 else if (GetFPRType () == eFPRTypeXSAVE) 747 { 748 lldb::ByteOrder byte_order = GetByteOrder (); 749 750 // Assemble the YMM register content from the register halves. 751 for (uint32_t reg = m_reg_info.first_ymm; reg <= m_reg_info.last_ymm; ++reg) 752 { 753 if (!CopyXSTATEtoYMM (reg, byte_order)) 754 { 755 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s CopyXSTATEtoYMM() failed for reg num %" PRIu32, __FUNCTION__, reg); 756 return error; 757 } 758 } 759 760 // Copy the extended register state including the assembled ymm registers. 761 ::memcpy (dst, &m_fpr, sizeof (m_fpr)); 762 } 763 else 764 { 765 assert (false && "how do we save the floating point registers?"); 766 error.SetErrorString ("unsure how to save the floating point registers"); 767 } 768 769 return error; 770 } 771 772 lldb_private::Error 773 NativeRegisterContextLinux_x86_64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp) 774 { 775 Error error; 776 777 if (!data_sp) 778 { 779 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s invalid data_sp provided", __FUNCTION__); 780 return error; 781 } 782 783 if (data_sp->GetByteSize () != REG_CONTEXT_SIZE) 784 { 785 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s data_sp contained mismatched data size, expected %" PRIu64 ", actual %" PRIu64, __FUNCTION__, REG_CONTEXT_SIZE, data_sp->GetByteSize ()); 786 return error; 787 } 788 789 790 uint8_t *src = data_sp->GetBytes (); 791 if (src == nullptr) 792 { 793 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s DataBuffer::GetBytes() returned a null pointer", __FUNCTION__); 794 return error; 795 } 796 ::memcpy (&m_gpr_x86_64, src, GetRegisterInfoInterface ().GetGPRSize ()); 797 798 if (!WriteGPR ()) 799 { 800 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s WriteGPR() failed", __FUNCTION__); 801 return error; 802 } 803 804 src += GetRegisterInfoInterface ().GetGPRSize (); 805 if (GetFPRType () == eFPRTypeFXSAVE) 806 ::memcpy (&m_fpr.xstate.fxsave, src, sizeof(m_fpr.xstate.fxsave)); 807 else if (GetFPRType () == eFPRTypeXSAVE) 808 ::memcpy (&m_fpr.xstate.xsave, src, sizeof(m_fpr.xstate.xsave)); 809 810 if (!WriteFPR ()) 811 { 812 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s WriteFPR() failed", __FUNCTION__); 813 return error; 814 } 815 816 if (GetFPRType() == eFPRTypeXSAVE) 817 { 818 lldb::ByteOrder byte_order = GetByteOrder(); 819 820 // Parse the YMM register content from the register halves. 821 for (uint32_t reg = m_reg_info.first_ymm; reg <= m_reg_info.last_ymm; ++reg) 822 { 823 if (!CopyYMMtoXSTATE (reg, byte_order)) 824 { 825 error.SetErrorStringWithFormat ("NativeRegisterContextLinux_x86_64::%s CopyYMMtoXSTATE() failed for reg num %" PRIu32, __FUNCTION__, reg); 826 return error; 827 } 828 } 829 } 830 831 return error; 832 } 833 834 bool 835 NativeRegisterContextLinux_x86_64::IsRegisterSetAvailable (uint32_t set_index) const 836 { 837 // Note: Extended register sets are assumed to be at the end of g_reg_sets. 838 uint32_t num_sets = k_num_register_sets - k_num_extended_register_sets; 839 840 if (GetFPRType () == eFPRTypeXSAVE) 841 { 842 // AVX is the first extended register set. 843 ++num_sets; 844 } 845 return (set_index < num_sets); 846 } 847 848 lldb::ByteOrder 849 NativeRegisterContextLinux_x86_64::GetByteOrder() const 850 { 851 // Get the target process whose privileged thread was used for the register read. 852 lldb::ByteOrder byte_order = lldb::eByteOrderInvalid; 853 854 NativeProcessProtocolSP process_sp (m_thread.GetProcess ()); 855 if (!process_sp) 856 return byte_order; 857 858 if (!process_sp->GetByteOrder (byte_order)) 859 { 860 // FIXME log here 861 } 862 863 return byte_order; 864 } 865 866 bool 867 NativeRegisterContextLinux_x86_64::IsGPR(uint32_t reg_index) const 868 { 869 // GPRs come first. 870 return reg_index <= m_reg_info.last_gpr; 871 } 872 873 NativeRegisterContextLinux_x86_64::FPRType 874 NativeRegisterContextLinux_x86_64::GetFPRType () const 875 { 876 if (m_fpr_type == eFPRTypeNotValid) 877 { 878 // TODO: Use assembly to call cpuid on the inferior and query ebx or ecx. 879 880 // Try and see if AVX register retrieval works. 881 m_fpr_type = eFPRTypeXSAVE; 882 if (!const_cast<NativeRegisterContextLinux_x86_64*> (this)->ReadFPR ()) 883 { 884 // Fall back to general floating point with no AVX support. 885 m_fpr_type = eFPRTypeFXSAVE; 886 } 887 } 888 889 return m_fpr_type; 890 } 891 892 bool 893 NativeRegisterContextLinux_x86_64::IsFPR(uint32_t reg_index) const 894 { 895 return (m_reg_info.first_fpr <= reg_index && reg_index <= m_reg_info.last_fpr); 896 } 897 898 bool 899 NativeRegisterContextLinux_x86_64::IsFPR(uint32_t reg_index, FPRType fpr_type) const 900 { 901 bool generic_fpr = IsFPR(reg_index); 902 903 if (fpr_type == eFPRTypeXSAVE) 904 return generic_fpr || IsAVX(reg_index); 905 return generic_fpr; 906 } 907 908 bool 909 NativeRegisterContextLinux_x86_64::WriteFPR() 910 { 911 NativeProcessProtocolSP process_sp (m_thread.GetProcess ()); 912 if (!process_sp) 913 return false; 914 NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ()); 915 916 if (GetFPRType() == eFPRTypeFXSAVE) 917 return process_p->WriteFPR (m_thread.GetID (), &m_fpr.xstate.fxsave, sizeof (m_fpr.xstate.fxsave)).Success(); 918 919 if (GetFPRType() == eFPRTypeXSAVE) 920 return process_p->WriteRegisterSet (m_thread.GetID (), &m_iovec, sizeof (m_fpr.xstate.xsave), NT_X86_XSTATE).Success(); 921 return false; 922 } 923 924 bool 925 NativeRegisterContextLinux_x86_64::IsAVX(uint32_t reg_index) const 926 { 927 return (m_reg_info.first_ymm <= reg_index && reg_index <= m_reg_info.last_ymm); 928 } 929 930 bool 931 NativeRegisterContextLinux_x86_64::CopyXSTATEtoYMM (uint32_t reg_index, lldb::ByteOrder byte_order) 932 { 933 if (!IsAVX (reg_index)) 934 return false; 935 936 if (byte_order == lldb::eByteOrderLittle) 937 { 938 ::memcpy (m_ymm_set.ymm[reg_index - m_reg_info.first_ymm].bytes, 939 m_fpr.xstate.fxsave.xmm[reg_index - m_reg_info.first_ymm].bytes, 940 sizeof (XMMReg)); 941 ::memcpy (m_ymm_set.ymm[reg_index - m_reg_info.first_ymm].bytes + sizeof (XMMReg), 942 m_fpr.xstate.xsave.ymmh[reg_index - m_reg_info.first_ymm].bytes, 943 sizeof (YMMHReg)); 944 return true; 945 } 946 947 if (byte_order == lldb::eByteOrderBig) 948 { 949 ::memcpy(m_ymm_set.ymm[reg_index - m_reg_info.first_ymm].bytes + sizeof (XMMReg), 950 m_fpr.xstate.fxsave.xmm[reg_index - m_reg_info.first_ymm].bytes, 951 sizeof (XMMReg)); 952 ::memcpy(m_ymm_set.ymm[reg_index - m_reg_info.first_ymm].bytes, 953 m_fpr.xstate.xsave.ymmh[reg_index - m_reg_info.first_ymm].bytes, 954 sizeof (YMMHReg)); 955 return true; 956 } 957 return false; // unsupported or invalid byte order 958 959 } 960 961 bool 962 NativeRegisterContextLinux_x86_64::CopyYMMtoXSTATE(uint32_t reg, lldb::ByteOrder byte_order) 963 { 964 if (!IsAVX(reg)) 965 return false; 966 967 if (byte_order == lldb::eByteOrderLittle) 968 { 969 ::memcpy(m_fpr.xstate.fxsave.xmm[reg - m_reg_info.first_ymm].bytes, 970 m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes, 971 sizeof(XMMReg)); 972 ::memcpy(m_fpr.xstate.xsave.ymmh[reg - m_reg_info.first_ymm].bytes, 973 m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes + sizeof(XMMReg), 974 sizeof(YMMHReg)); 975 return true; 976 } 977 978 if (byte_order == lldb::eByteOrderBig) 979 { 980 ::memcpy(m_fpr.xstate.fxsave.xmm[reg - m_reg_info.first_ymm].bytes, 981 m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes + sizeof(XMMReg), 982 sizeof(XMMReg)); 983 ::memcpy(m_fpr.xstate.xsave.ymmh[reg - m_reg_info.first_ymm].bytes, 984 m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes, 985 sizeof(YMMHReg)); 986 return true; 987 } 988 return false; // unsupported or invalid byte order 989 } 990 991 bool 992 NativeRegisterContextLinux_x86_64::ReadFPR () 993 { 994 NativeProcessProtocolSP process_sp (m_thread.GetProcess ()); 995 if (!process_sp) 996 return false; 997 NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ()); 998 999 const FPRType fpr_type = GetFPRType (); 1000 switch (fpr_type) 1001 { 1002 case FPRType::eFPRTypeFXSAVE: 1003 return process_p->ReadFPR (m_thread.GetID (), &m_fpr.xstate.fxsave, sizeof (m_fpr.xstate.fxsave)).Success(); 1004 1005 case FPRType::eFPRTypeXSAVE: 1006 return process_p->ReadRegisterSet (m_thread.GetID (), &m_iovec, sizeof (m_fpr.xstate.xsave), NT_X86_XSTATE).Success(); 1007 1008 default: 1009 return false; 1010 } 1011 } 1012 1013 bool 1014 NativeRegisterContextLinux_x86_64::ReadGPR() 1015 { 1016 NativeProcessProtocolSP process_sp (m_thread.GetProcess ()); 1017 if (!process_sp) 1018 return false; 1019 NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ()); 1020 1021 return process_p->ReadGPR (m_thread.GetID (), &m_gpr_x86_64, GetRegisterInfoInterface ().GetGPRSize ()).Success(); 1022 } 1023 1024 bool 1025 NativeRegisterContextLinux_x86_64::WriteGPR() 1026 { 1027 NativeProcessProtocolSP process_sp (m_thread.GetProcess ()); 1028 if (!process_sp) 1029 return false; 1030 NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ()); 1031 1032 return process_p->WriteGPR (m_thread.GetID (), &m_gpr_x86_64, GetRegisterInfoInterface ().GetGPRSize ()).Success(); 1033 } 1034 1035 Error 1036 NativeRegisterContextLinux_x86_64::IsWatchpointHit(uint8_t wp_index) 1037 { 1038 if (wp_index >= NumSupportedHardwareWatchpoints()) 1039 return Error ("Watchpoint index out of range"); 1040 1041 RegisterValue reg_value; 1042 Error error = ReadRegisterRaw(lldb_dr6_x86_64, reg_value); 1043 if (error.Fail()) return error; 1044 1045 uint64_t status_bits = reg_value.GetAsUInt64(); 1046 1047 bool is_hit = status_bits & (1 << wp_index); 1048 1049 error.SetError (!is_hit, lldb::eErrorTypeInvalid); 1050 1051 return error; 1052 } 1053 1054 Error 1055 NativeRegisterContextLinux_x86_64::IsWatchpointVacant(uint32_t wp_index) 1056 { 1057 if (wp_index >= NumSupportedHardwareWatchpoints()) 1058 return Error ("Watchpoint index out of range"); 1059 1060 RegisterValue reg_value; 1061 Error error = ReadRegisterRaw(lldb_dr7_x86_64, reg_value); 1062 if (error.Fail()) return error; 1063 1064 uint64_t control_bits = reg_value.GetAsUInt64(); 1065 1066 bool is_vacant = !(control_bits & (1 << (2 * wp_index))); 1067 1068 error.SetError (!is_vacant, lldb::eErrorTypeInvalid); 1069 1070 return error; 1071 } 1072 1073 Error 1074 NativeRegisterContextLinux_x86_64::SetHardwareWatchpointWithIndex( 1075 lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) { 1076 1077 if (wp_index >= NumSupportedHardwareWatchpoints()) 1078 return Error ("Watchpoint index out of range"); 1079 1080 if (watch_flags != 0x1 && watch_flags != 0x3) 1081 return Error ("Invalid read/write bits for watchpoint"); 1082 1083 if (size != 1 && size != 2 && size != 4 && size != 8) 1084 return Error ("Invalid size for watchpoint"); 1085 1086 Error error = IsWatchpointVacant (wp_index); 1087 if (error.Fail()) return error; 1088 1089 RegisterValue reg_value; 1090 error = ReadRegisterRaw(lldb_dr7_x86_64, reg_value); 1091 if (error.Fail()) return error; 1092 1093 // for watchpoints 0, 1, 2, or 3, respectively, 1094 // set bits 1, 3, 5, or 7 1095 uint64_t enable_bit = 1 << (2 * wp_index); 1096 1097 // set bits 16-17, 20-21, 24-25, or 28-29 1098 // with 0b01 for write, and 0b11 for read/write 1099 uint64_t rw_bits = watch_flags << (16 + 4 * wp_index); 1100 1101 // set bits 18-19, 22-23, 26-27, or 30-31 1102 // with 0b00, 0b01, 0b10, or 0b11 1103 // for 1, 2, 8 (if supported), or 4 bytes, respectively 1104 uint64_t size_bits = (size == 8 ? 0x2 : size - 1) << (18 + 4 * wp_index); 1105 1106 uint64_t bit_mask = (0x3 << (2 * wp_index)) | (0xF << (16 + 4 * wp_index)); 1107 1108 uint64_t control_bits = reg_value.GetAsUInt64() & ~bit_mask; 1109 1110 control_bits |= enable_bit | rw_bits | size_bits; 1111 1112 error = WriteRegister(m_reg_info.first_dr + wp_index, RegisterValue(addr)); 1113 if (error.Fail()) return error; 1114 1115 error = WriteRegister(lldb_dr7_x86_64, RegisterValue(control_bits)); 1116 if (error.Fail()) return error; 1117 1118 error.Clear(); 1119 return error; 1120 } 1121 1122 bool 1123 NativeRegisterContextLinux_x86_64::ClearHardwareWatchpoint(uint32_t wp_index) 1124 { 1125 if (wp_index >= NumSupportedHardwareWatchpoints()) 1126 return false; 1127 1128 RegisterValue reg_value; 1129 1130 // for watchpoints 0, 1, 2, or 3, respectively, 1131 // clear bits 0, 1, 2, or 3 of the debug status register (DR6) 1132 Error error = ReadRegisterRaw(lldb_dr6_x86_64, reg_value); 1133 if (error.Fail()) return false; 1134 uint64_t bit_mask = 1 << wp_index; 1135 uint64_t status_bits = reg_value.GetAsUInt64() & ~bit_mask; 1136 error = WriteRegister(lldb_dr6_x86_64, RegisterValue(status_bits)); 1137 if (error.Fail()) return false; 1138 1139 // for watchpoints 0, 1, 2, or 3, respectively, 1140 // clear bits {0-1,16-19}, {2-3,20-23}, {4-5,24-27}, or {6-7,28-31} 1141 // of the debug control register (DR7) 1142 error = ReadRegisterRaw(lldb_dr7_x86_64, reg_value); 1143 if (error.Fail()) return false; 1144 bit_mask = (0x3 << (2 * wp_index)) | (0xF << (16 + 4 * wp_index)); 1145 uint64_t control_bits = reg_value.GetAsUInt64() & ~bit_mask; 1146 return WriteRegister(lldb_dr7_x86_64, RegisterValue(control_bits)).Success(); 1147 } 1148 1149 Error 1150 NativeRegisterContextLinux_x86_64::ClearAllHardwareWatchpoints() 1151 { 1152 RegisterValue reg_value; 1153 1154 // clear bits {0-4} of the debug status register (DR6) 1155 Error error = ReadRegisterRaw(lldb_dr6_x86_64, reg_value); 1156 if (error.Fail()) return error; 1157 uint64_t bit_mask = 0xF; 1158 uint64_t status_bits = reg_value.GetAsUInt64() & ~bit_mask; 1159 error = WriteRegister(lldb_dr6_x86_64, RegisterValue(status_bits)); 1160 if (error.Fail()) return error; 1161 1162 // clear bits {0-7,16-31} of the debug control register (DR7) 1163 error = ReadRegisterRaw(lldb_dr7_x86_64, reg_value); 1164 if (error.Fail()) return error; 1165 bit_mask = 0xFF | (0xFFFF << 16); 1166 uint64_t control_bits = reg_value.GetAsUInt64() & ~bit_mask; 1167 return WriteRegister(lldb_dr7_x86_64, RegisterValue(control_bits)); 1168 } 1169 1170 uint32_t 1171 NativeRegisterContextLinux_x86_64::SetHardwareWatchpoint( 1172 lldb::addr_t addr, size_t size, uint32_t watch_flags) 1173 { 1174 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints(); 1175 for (uint32_t wp_index = 0; wp_index < num_hw_watchpoints; ++wp_index) 1176 if (IsWatchpointVacant(wp_index).Success()) 1177 { 1178 if (SetHardwareWatchpointWithIndex(addr, size, watch_flags, wp_index).Fail()) 1179 continue; 1180 return wp_index; 1181 } 1182 return LLDB_INVALID_INDEX32; 1183 } 1184 1185 lldb::addr_t 1186 NativeRegisterContextLinux_x86_64::GetWatchpointAddress(uint32_t wp_index) 1187 { 1188 if (wp_index >= NumSupportedHardwareWatchpoints()) 1189 return LLDB_INVALID_ADDRESS; 1190 RegisterValue reg_value; 1191 if (ReadRegisterRaw(m_reg_info.first_dr + wp_index, reg_value).Fail()) 1192 return LLDB_INVALID_ADDRESS; 1193 return reg_value.GetAsUInt64(); 1194 } 1195 1196 uint32_t 1197 NativeRegisterContextLinux_x86_64::NumSupportedHardwareWatchpoints () 1198 { 1199 // Available debug address registers: dr0, dr1, dr2, dr3 1200 return 4; 1201 } 1202