1//===-- RegisterContextPOSIXProcessMonitor_x86.h ---------------*- 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 "lldb/Target/Thread.h" 11#include "lldb/Core/RegisterValue.h" 12 13#include "ProcessPOSIX.h" 14#include "RegisterContextPOSIXProcessMonitor_x86.h" 15#include "ProcessMonitor.h" 16 17using namespace lldb_private; 18using namespace lldb; 19 20// Support ptrace extensions even when compiled without required kernel support 21#ifndef NT_X86_XSTATE 22 #define NT_X86_XSTATE 0x202 23#endif 24 25#define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(FPR)) 26 27static uint32_t 28size_and_rw_bits(size_t size, bool read, bool write) 29{ 30 uint32_t rw; 31 32 if (read) 33 rw = 0x3; // READ or READ/WRITE 34 else if (write) 35 rw = 0x1; // WRITE 36 else 37 assert(0 && "read and write cannot both be false"); 38 39 switch (size) 40 { 41 case 1: 42 return rw; 43 case 2: 44 return (0x1 << 2) | rw; 45 case 4: 46 return (0x3 << 2) | rw; 47 case 8: 48 return (0x2 << 2) | rw; 49 default: 50 assert(0 && "invalid size, must be one of 1, 2, 4, or 8"); 51 } 52} 53 54RegisterContextPOSIXProcessMonitor_x86_64::RegisterContextPOSIXProcessMonitor_x86_64(Thread &thread, 55 uint32_t concrete_frame_idx, 56 RegisterInfoInterface *register_info) 57 : RegisterContextPOSIX_x86(thread, concrete_frame_idx, register_info) 58{ 59} 60 61ProcessMonitor & 62RegisterContextPOSIXProcessMonitor_x86_64::GetMonitor() 63{ 64 ProcessSP base = CalculateProcess(); 65 ProcessPOSIX *process = static_cast<ProcessPOSIX*>(base.get()); 66 return process->GetMonitor(); 67} 68 69bool 70RegisterContextPOSIXProcessMonitor_x86_64::ReadGPR() 71{ 72 ProcessMonitor &monitor = GetMonitor(); 73 return monitor.ReadGPR(m_thread.GetID(), &m_gpr_x86_64, GetGPRSize()); 74} 75 76bool 77RegisterContextPOSIXProcessMonitor_x86_64::ReadFPR() 78{ 79 ProcessMonitor &monitor = GetMonitor(); 80 if (GetFPRType() == eFXSAVE) 81 return monitor.ReadFPR(m_thread.GetID(), &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave)); 82 83 if (GetFPRType() == eXSAVE) 84 return monitor.ReadRegisterSet(m_thread.GetID(), &m_iovec, sizeof(m_fpr.xstate.xsave), NT_X86_XSTATE); 85 return false; 86} 87 88bool 89RegisterContextPOSIXProcessMonitor_x86_64::WriteGPR() 90{ 91 ProcessMonitor &monitor = GetMonitor(); 92 return monitor.WriteGPR(m_thread.GetID(), &m_gpr_x86_64, GetGPRSize()); 93} 94 95bool 96RegisterContextPOSIXProcessMonitor_x86_64::WriteFPR() 97{ 98 ProcessMonitor &monitor = GetMonitor(); 99 if (GetFPRType() == eFXSAVE) 100 return monitor.WriteFPR(m_thread.GetID(), &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave)); 101 102 if (GetFPRType() == eXSAVE) 103 return monitor.WriteRegisterSet(m_thread.GetID(), &m_iovec, sizeof(m_fpr.xstate.xsave), NT_X86_XSTATE); 104 return false; 105} 106 107bool 108RegisterContextPOSIXProcessMonitor_x86_64::ReadRegister(const unsigned reg, 109 RegisterValue &value) 110{ 111 ProcessMonitor &monitor = GetMonitor(); 112 113#if defined(__FreeBSD__) 114 if (reg >= m_reg_info.first_dr) 115 return monitor.ReadDebugRegisterValue(m_thread.GetID(), 116 GetRegisterOffset(reg), 117 GetRegisterName(reg), 118 GetRegisterSize(reg), 119 value); 120#endif 121 return monitor.ReadRegisterValue(m_thread.GetID(), 122 GetRegisterOffset(reg), 123 GetRegisterName(reg), 124 GetRegisterSize(reg), 125 value); 126} 127 128bool 129RegisterContextPOSIXProcessMonitor_x86_64::WriteRegister(const unsigned reg, 130 const RegisterValue &value) 131{ 132 unsigned reg_to_write = reg; 133 RegisterValue value_to_write = value; 134 135 // Check if this is a subregister of a full register. 136 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 137 if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) 138 { 139 RegisterValue full_value; 140 uint32_t full_reg = reg_info->invalidate_regs[0]; 141 const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg); 142 143 // Read the full register. 144 if (ReadRegister(full_reg_info, full_value)) 145 { 146 Error error; 147 ByteOrder byte_order = GetByteOrder(); 148 uint8_t dst[RegisterValue::kMaxRegisterByteSize]; 149 150 // Get the bytes for the full register. 151 const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info, 152 dst, 153 sizeof(dst), 154 byte_order, 155 error); 156 if (error.Success() && dest_size) 157 { 158 uint8_t src[RegisterValue::kMaxRegisterByteSize]; 159 160 // Get the bytes for the source data. 161 const uint32_t src_size = value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error); 162 if (error.Success() && src_size && (src_size < dest_size)) 163 { 164 // Copy the src bytes to the destination. 165 memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size); 166 // Set this full register as the value to write. 167 value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order); 168 value_to_write.SetType(full_reg_info); 169 reg_to_write = full_reg; 170 } 171 } 172 } 173 } 174 175 ProcessMonitor &monitor = GetMonitor(); 176#if defined(__FreeBSD__) 177 if (reg >= m_reg_info.first_dr) 178 return monitor.WriteDebugRegisterValue(m_thread.GetID(), 179 GetRegisterOffset(reg_to_write), 180 GetRegisterName(reg_to_write), 181 value_to_write); 182#endif 183 return monitor.WriteRegisterValue(m_thread.GetID(), 184 GetRegisterOffset(reg_to_write), 185 GetRegisterName(reg_to_write), 186 value_to_write); 187} 188 189bool 190RegisterContextPOSIXProcessMonitor_x86_64::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value) 191{ 192 if (!reg_info) 193 return false; 194 195 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; 196 197 if (IsFPR(reg, GetFPRType())) 198 { 199 if (!ReadFPR()) 200 return false; 201 } 202 else 203 { 204 uint32_t full_reg = reg; 205 bool is_subreg = reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM); 206 207 if (is_subreg) 208 { 209 // Read the full aligned 64-bit register. 210 full_reg = reg_info->invalidate_regs[0]; 211 } 212 213 bool success = ReadRegister(full_reg, value); 214 215 if (success) 216 { 217 // If our read was not aligned (for ah,bh,ch,dh), shift our returned value one byte to the right. 218 if (is_subreg && (reg_info->byte_offset & 0x1)) 219 value.SetUInt64(value.GetAsUInt64() >> 8); 220 221 // If our return byte size was greater than the return value reg size, then 222 // use the type specified by reg_info rather than the uint64_t default 223 if (value.GetByteSize() > reg_info->byte_size) 224 value.SetType(reg_info); 225 } 226 return success; 227 } 228 229 if (reg_info->encoding == eEncodingVector) 230 { 231 ByteOrder byte_order = GetByteOrder(); 232 233 if (byte_order != ByteOrder::eByteOrderInvalid) 234 { 235 if (reg >= m_reg_info.first_st && reg <= m_reg_info.last_st) 236 value.SetBytes(m_fpr.xstate.fxsave.stmm[reg - m_reg_info.first_st].bytes, reg_info->byte_size, byte_order); 237 if (reg >= m_reg_info.first_mm && reg <= m_reg_info.last_mm) 238 value.SetBytes(m_fpr.xstate.fxsave.stmm[reg - m_reg_info.first_mm].bytes, reg_info->byte_size, byte_order); 239 if (reg >= m_reg_info.first_xmm && reg <= m_reg_info.last_xmm) 240 value.SetBytes(m_fpr.xstate.fxsave.xmm[reg - m_reg_info.first_xmm].bytes, reg_info->byte_size, byte_order); 241 if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) 242 { 243 // Concatenate ymm using the register halves in xmm.bytes and ymmh.bytes 244 if (GetFPRType() == eXSAVE && CopyXSTATEtoYMM(reg, byte_order)) 245 value.SetBytes(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes, reg_info->byte_size, byte_order); 246 else 247 return false; 248 } 249 return value.GetType() == RegisterValue::eTypeBytes; 250 } 251 return false; 252 } 253 254 // Get pointer to m_fpr.xstate.fxsave variable and set the data from it. 255 assert (reg_info->byte_offset < sizeof(m_fpr)); 256 uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset; 257 switch (reg_info->byte_size) 258 { 259 case 2: 260 value.SetUInt16(*(uint16_t *)src); 261 return true; 262 case 4: 263 value.SetUInt32(*(uint32_t *)src); 264 return true; 265 case 8: 266 value.SetUInt64(*(uint64_t *)src); 267 return true; 268 default: 269 assert(false && "Unhandled data size."); 270 return false; 271 } 272} 273 274bool 275RegisterContextPOSIXProcessMonitor_x86_64::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value) 276{ 277 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; 278 279 if (IsGPR(reg)) 280 return WriteRegister(reg, value); 281 282 if (IsFPR(reg, GetFPRType())) 283 { 284 if (reg_info->encoding == eEncodingVector) 285 { 286 if (reg >= m_reg_info.first_st && reg <= m_reg_info.last_st) 287 ::memcpy (m_fpr.xstate.fxsave.stmm[reg - m_reg_info.first_st].bytes, value.GetBytes(), value.GetByteSize()); 288 289 if (reg >= m_reg_info.first_mm && reg <= m_reg_info.last_mm) 290 ::memcpy (m_fpr.xstate.fxsave.stmm[reg - m_reg_info.first_mm].bytes, value.GetBytes(), value.GetByteSize()); 291 292 if (reg >= m_reg_info.first_xmm && reg <= m_reg_info.last_xmm) 293 ::memcpy (m_fpr.xstate.fxsave.xmm[reg - m_reg_info.first_xmm].bytes, value.GetBytes(), value.GetByteSize()); 294 295 if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) 296 { 297 if (GetFPRType() != eXSAVE) 298 return false; // the target processor does not support AVX 299 300 // Store ymm register content, and split into the register halves in xmm.bytes and ymmh.bytes 301 ::memcpy (m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes, value.GetBytes(), value.GetByteSize()); 302 if (false == CopyYMMtoXSTATE(reg, GetByteOrder())) 303 return false; 304 } 305 } 306 else 307 { 308 // Get pointer to m_fpr.xstate.fxsave variable and set the data to it. 309 assert (reg_info->byte_offset < sizeof(m_fpr)); 310 uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset; 311 switch (reg_info->byte_size) 312 { 313 case 2: 314 *(uint16_t *)dst = value.GetAsUInt16(); 315 break; 316 case 4: 317 *(uint32_t *)dst = value.GetAsUInt32(); 318 break; 319 case 8: 320 *(uint64_t *)dst = value.GetAsUInt64(); 321 break; 322 default: 323 assert(false && "Unhandled data size."); 324 return false; 325 } 326 } 327 328 if (WriteFPR()) 329 { 330 if (IsAVX(reg)) 331 return CopyYMMtoXSTATE(reg, GetByteOrder()); 332 return true; 333 } 334 } 335 return false; 336} 337 338bool 339RegisterContextPOSIXProcessMonitor_x86_64::ReadAllRegisterValues(DataBufferSP &data_sp) 340{ 341 bool success = false; 342 data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0)); 343 if (data_sp && ReadGPR () && ReadFPR ()) 344 { 345 uint8_t *dst = data_sp->GetBytes(); 346 success = dst != 0; 347 348 if (success) 349 { 350 ::memcpy (dst, &m_gpr_x86_64, GetGPRSize()); 351 dst += GetGPRSize(); 352 } 353 if (GetFPRType() == eFXSAVE) 354 ::memcpy (dst, &m_fpr.xstate.fxsave, sizeof(m_fpr.xstate.fxsave)); 355 356 if (GetFPRType() == eXSAVE) 357 { 358 ByteOrder byte_order = GetByteOrder(); 359 360 // Assemble the YMM register content from the register halves. 361 for (uint32_t reg = m_reg_info.first_ymm; success && reg <= m_reg_info.last_ymm; ++reg) 362 success = CopyXSTATEtoYMM(reg, byte_order); 363 364 if (success) 365 { 366 // Copy the extended register state including the assembled ymm registers. 367 ::memcpy (dst, &m_fpr, sizeof(m_fpr)); 368 } 369 } 370 } 371 return success; 372} 373 374bool 375RegisterContextPOSIXProcessMonitor_x86_64::WriteAllRegisterValues(const DataBufferSP &data_sp) 376{ 377 bool success = false; 378 if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) 379 { 380 uint8_t *src = data_sp->GetBytes(); 381 if (src) 382 { 383 ::memcpy (&m_gpr_x86_64, src, GetGPRSize()); 384 385 if (WriteGPR()) 386 { 387 src += GetGPRSize(); 388 if (GetFPRType() == eFXSAVE) 389 ::memcpy (&m_fpr.xstate.fxsave, src, sizeof(m_fpr.xstate.fxsave)); 390 if (GetFPRType() == eXSAVE) 391 ::memcpy (&m_fpr.xstate.xsave, src, sizeof(m_fpr.xstate.xsave)); 392 393 success = WriteFPR(); 394 if (success) 395 { 396 if (GetFPRType() == eXSAVE) 397 { 398 ByteOrder byte_order = GetByteOrder(); 399 400 // Parse the YMM register content from the register halves. 401 for (uint32_t reg = m_reg_info.first_ymm; success && reg <= m_reg_info.last_ymm; ++reg) 402 success = CopyYMMtoXSTATE(reg, byte_order); 403 } 404 } 405 } 406 } 407 } 408 return success; 409} 410 411uint32_t 412RegisterContextPOSIXProcessMonitor_x86_64::SetHardwareWatchpoint(addr_t addr, size_t size, 413 bool read, bool write) 414{ 415 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints(); 416 uint32_t hw_index; 417 418 for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) 419 { 420 if (IsWatchpointVacant(hw_index)) 421 return SetHardwareWatchpointWithIndex(addr, size, 422 read, write, 423 hw_index); 424 } 425 426 return LLDB_INVALID_INDEX32; 427} 428 429bool 430RegisterContextPOSIXProcessMonitor_x86_64::ClearHardwareWatchpoint(uint32_t hw_index) 431{ 432 if (hw_index < NumSupportedHardwareWatchpoints()) 433 { 434 RegisterValue current_dr7_bits; 435 436 if (ReadRegister(m_reg_info.first_dr + 7, current_dr7_bits)) 437 { 438 uint64_t new_dr7_bits = current_dr7_bits.GetAsUInt64() & ~(3 << (2*hw_index)); 439 440 if (WriteRegister(m_reg_info.first_dr + 7, RegisterValue(new_dr7_bits))) 441 return true; 442 } 443 } 444 445 return false; 446} 447 448bool 449RegisterContextPOSIXProcessMonitor_x86_64::HardwareSingleStep(bool enable) 450{ 451 enum { TRACE_BIT = 0x100 }; 452 uint64_t rflags; 453 454 if ((rflags = ReadRegisterAsUnsigned(m_reg_info.gpr_flags, -1UL)) == -1UL) 455 return false; 456 457 if (enable) 458 { 459 if (rflags & TRACE_BIT) 460 return true; 461 462 rflags |= TRACE_BIT; 463 } 464 else 465 { 466 if (!(rflags & TRACE_BIT)) 467 return false; 468 469 rflags &= ~TRACE_BIT; 470 } 471 472 return WriteRegisterFromUnsigned(m_reg_info.gpr_flags, rflags); 473} 474 475bool 476RegisterContextPOSIXProcessMonitor_x86_64::UpdateAfterBreakpoint() 477{ 478 // PC points one byte past the int3 responsible for the breakpoint. 479 lldb::addr_t pc; 480 481 if ((pc = GetPC()) == LLDB_INVALID_ADDRESS) 482 return false; 483 484 SetPC(pc - 1); 485 return true; 486} 487 488unsigned 489RegisterContextPOSIXProcessMonitor_x86_64::GetRegisterIndexFromOffset(unsigned offset) 490{ 491 unsigned reg; 492 for (reg = 0; reg < m_reg_info.num_registers; reg++) 493 { 494 if (GetRegisterInfo()[reg].byte_offset == offset) 495 break; 496 } 497 assert(reg < m_reg_info.num_registers && "Invalid register offset."); 498 return reg; 499} 500 501bool 502RegisterContextPOSIXProcessMonitor_x86_64::IsWatchpointHit(uint32_t hw_index) 503{ 504 bool is_hit = false; 505 506 if (m_watchpoints_initialized == false) 507 { 508 // Reset the debug status and debug control registers 509 RegisterValue zero_bits = RegisterValue(uint64_t(0)); 510 if (!WriteRegister(m_reg_info.first_dr + 6, zero_bits) || !WriteRegister(m_reg_info.first_dr + 7, zero_bits)) 511 assert(false && "Could not initialize watchpoint registers"); 512 m_watchpoints_initialized = true; 513 } 514 515 if (hw_index < NumSupportedHardwareWatchpoints()) 516 { 517 RegisterValue value; 518 519 if (ReadRegister(m_reg_info.first_dr + 6, value)) 520 { 521 uint64_t val = value.GetAsUInt64(); 522 is_hit = val & (1 << hw_index); 523 } 524 } 525 526 return is_hit; 527} 528 529bool 530RegisterContextPOSIXProcessMonitor_x86_64::ClearWatchpointHits() 531{ 532 return WriteRegister(m_reg_info.first_dr + 6, RegisterValue((uint64_t)0)); 533} 534 535addr_t 536RegisterContextPOSIXProcessMonitor_x86_64::GetWatchpointAddress(uint32_t hw_index) 537{ 538 addr_t wp_monitor_addr = LLDB_INVALID_ADDRESS; 539 540 if (hw_index < NumSupportedHardwareWatchpoints()) 541 { 542 if (!IsWatchpointVacant(hw_index)) 543 { 544 RegisterValue value; 545 546 if (ReadRegister(m_reg_info.first_dr + hw_index, value)) 547 wp_monitor_addr = value.GetAsUInt64(); 548 } 549 } 550 551 return wp_monitor_addr; 552} 553 554bool 555RegisterContextPOSIXProcessMonitor_x86_64::IsWatchpointVacant(uint32_t hw_index) 556{ 557 bool is_vacant = false; 558 RegisterValue value; 559 560 assert(hw_index < NumSupportedHardwareWatchpoints()); 561 562 if (m_watchpoints_initialized == false) 563 { 564 // Reset the debug status and debug control registers 565 RegisterValue zero_bits = RegisterValue(uint64_t(0)); 566 if (!WriteRegister(m_reg_info.first_dr + 6, zero_bits) || !WriteRegister(m_reg_info.first_dr + 7, zero_bits)) 567 assert(false && "Could not initialize watchpoint registers"); 568 m_watchpoints_initialized = true; 569 } 570 571 if (ReadRegister(m_reg_info.first_dr + 7, value)) 572 { 573 uint64_t val = value.GetAsUInt64(); 574 is_vacant = (val & (3 << 2*hw_index)) == 0; 575 } 576 577 return is_vacant; 578} 579 580bool 581RegisterContextPOSIXProcessMonitor_x86_64::SetHardwareWatchpointWithIndex(addr_t addr, size_t size, 582 bool read, bool write, 583 uint32_t hw_index) 584{ 585 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints(); 586 587 if (num_hw_watchpoints == 0 || hw_index >= num_hw_watchpoints) 588 return false; 589 590 if (!(size == 1 || size == 2 || size == 4 || size == 8)) 591 return false; 592 593 if (read == false && write == false) 594 return false; 595 596 if (!IsWatchpointVacant(hw_index)) 597 return false; 598 599 // Set both dr7 (debug control register) and dri (debug address register). 600 601 // dr7{7-0} encodes the local/global enable bits: 602 // global enable --. .-- local enable 603 // | | 604 // v v 605 // dr0 -> bits{1-0} 606 // dr1 -> bits{3-2} 607 // dr2 -> bits{5-4} 608 // dr3 -> bits{7-6} 609 // 610 // dr7{31-16} encodes the rw/len bits: 611 // b_x+3, b_x+2, b_x+1, b_x 612 // where bits{x+1, x} => rw 613 // 0b00: execute, 0b01: write, 0b11: read-or-write, 614 // 0b10: io read-or-write (unused) 615 // and bits{x+3, x+2} => len 616 // 0b00: 1-byte, 0b01: 2-byte, 0b11: 4-byte, 0b10: 8-byte 617 // 618 // dr0 -> bits{19-16} 619 // dr1 -> bits{23-20} 620 // dr2 -> bits{27-24} 621 // dr3 -> bits{31-28} 622 if (hw_index < num_hw_watchpoints) 623 { 624 RegisterValue current_dr7_bits; 625 626 if (ReadRegister(m_reg_info.first_dr + 7, current_dr7_bits)) 627 { 628 uint64_t new_dr7_bits = current_dr7_bits.GetAsUInt64() | 629 (1 << (2*hw_index) | 630 size_and_rw_bits(size, read, write) << 631 (16+4*hw_index)); 632 633 if (WriteRegister(m_reg_info.first_dr + hw_index, RegisterValue(addr)) && 634 WriteRegister(m_reg_info.first_dr + 7, RegisterValue(new_dr7_bits))) 635 return true; 636 } 637 } 638 639 return false; 640} 641 642uint32_t 643RegisterContextPOSIXProcessMonitor_x86_64::NumSupportedHardwareWatchpoints() 644{ 645 // Available debug address registers: dr0, dr1, dr2, dr3 646 return 4; 647} 648 649