1 //===-- RegisterContext.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 // C Includes 11 // C++ Includes 12 // Other libraries and framework includes 13 // Project includes 14 #include "lldb/Target/RegisterContext.h" 15 #include "lldb/Core/DataExtractor.h" 16 #include "lldb/Core/RegisterValue.h" 17 #include "lldb/Core/Scalar.h" 18 #include "lldb/Host/Endian.h" 19 #include "lldb/Target/ExecutionContext.h" 20 #include "lldb/Target/StackFrame.h" 21 #include "lldb/Target/Process.h" 22 #include "lldb/Target/Thread.h" 23 24 using namespace lldb; 25 using namespace lldb_private; 26 27 RegisterContext::RegisterContext (Thread &thread, uint32_t concrete_frame_idx) : 28 m_thread (thread), 29 m_concrete_frame_idx (concrete_frame_idx), 30 m_stop_id (thread.GetProcess()->GetStopID()) 31 { 32 } 33 34 //---------------------------------------------------------------------- 35 // Destructor 36 //---------------------------------------------------------------------- 37 RegisterContext::~RegisterContext() 38 { 39 } 40 41 void 42 RegisterContext::InvalidateIfNeeded (bool force) 43 { 44 ProcessSP process_sp (m_thread.GetProcess()); 45 bool invalidate = force; 46 uint32_t process_stop_id = UINT32_MAX; 47 48 if (process_sp) 49 process_stop_id = process_sp->GetStopID(); 50 else 51 invalidate = true; 52 53 if (!invalidate) 54 invalidate = process_stop_id != GetStopID(); 55 56 if (invalidate) 57 { 58 InvalidateAllRegisters (); 59 SetStopID (process_stop_id); 60 } 61 } 62 63 64 const RegisterInfo * 65 RegisterContext::GetRegisterInfoByName (const char *reg_name, uint32_t start_idx) 66 { 67 if (reg_name && reg_name[0]) 68 { 69 const uint32_t num_registers = GetRegisterCount(); 70 for (uint32_t reg = start_idx; reg < num_registers; ++reg) 71 { 72 const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); 73 74 if ((reg_info->name != NULL && ::strcasecmp (reg_info->name, reg_name) == 0) || 75 (reg_info->alt_name != NULL && ::strcasecmp (reg_info->alt_name, reg_name) == 0)) 76 { 77 return reg_info; 78 } 79 } 80 } 81 return NULL; 82 } 83 84 const char * 85 RegisterContext::GetRegisterName (uint32_t reg) 86 { 87 const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); 88 if (reg_info) 89 return reg_info->name; 90 return NULL; 91 } 92 93 uint64_t 94 RegisterContext::GetPC(uint64_t fail_value) 95 { 96 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 97 return ReadRegisterAsUnsigned (reg, fail_value); 98 } 99 100 bool 101 RegisterContext::SetPC(uint64_t pc) 102 { 103 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 104 bool success = WriteRegisterFromUnsigned (reg, pc); 105 if (success) 106 { 107 StackFrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx)); 108 if (frame_sp) 109 frame_sp->ChangePC(pc); 110 else 111 m_thread.ClearStackFrames (); 112 } 113 return success; 114 } 115 116 uint64_t 117 RegisterContext::GetSP(uint64_t fail_value) 118 { 119 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 120 return ReadRegisterAsUnsigned (reg, fail_value); 121 } 122 123 bool 124 RegisterContext::SetSP(uint64_t sp) 125 { 126 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 127 return WriteRegisterFromUnsigned (reg, sp); 128 } 129 130 uint64_t 131 RegisterContext::GetFP(uint64_t fail_value) 132 { 133 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); 134 return ReadRegisterAsUnsigned (reg, fail_value); 135 } 136 137 bool 138 RegisterContext::SetFP(uint64_t fp) 139 { 140 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); 141 return WriteRegisterFromUnsigned (reg, fp); 142 } 143 144 uint64_t 145 RegisterContext::GetReturnAddress (uint64_t fail_value) 146 { 147 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); 148 return ReadRegisterAsUnsigned (reg, fail_value); 149 } 150 151 uint64_t 152 RegisterContext::GetFlags (uint64_t fail_value) 153 { 154 uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS); 155 return ReadRegisterAsUnsigned (reg, fail_value); 156 } 157 158 159 uint64_t 160 RegisterContext::ReadRegisterAsUnsigned (uint32_t reg, uint64_t fail_value) 161 { 162 if (reg != LLDB_INVALID_REGNUM) 163 return ReadRegisterAsUnsigned (GetRegisterInfoAtIndex (reg), fail_value); 164 return fail_value; 165 } 166 167 uint64_t 168 RegisterContext::ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value) 169 { 170 if (reg_info) 171 { 172 RegisterValue value; 173 if (ReadRegister (reg_info, value)) 174 return value.GetAsUInt64(); 175 } 176 return fail_value; 177 } 178 179 bool 180 RegisterContext::WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval) 181 { 182 if (reg == LLDB_INVALID_REGNUM) 183 return false; 184 return WriteRegisterFromUnsigned (GetRegisterInfoAtIndex (reg), uval); 185 } 186 187 bool 188 RegisterContext::WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval) 189 { 190 if (reg_info) 191 { 192 RegisterValue value; 193 if (value.SetUInt(uval, reg_info->byte_size)) 194 return WriteRegister (reg_info, value); 195 } 196 return false; 197 } 198 199 lldb::tid_t 200 RegisterContext::GetThreadID() const 201 { 202 return m_thread.GetID(); 203 } 204 205 uint32_t 206 RegisterContext::NumSupportedHardwareBreakpoints () 207 { 208 return 0; 209 } 210 211 uint32_t 212 RegisterContext::SetHardwareBreakpoint (lldb::addr_t addr, size_t size) 213 { 214 return LLDB_INVALID_INDEX32; 215 } 216 217 bool 218 RegisterContext::ClearHardwareBreakpoint (uint32_t hw_idx) 219 { 220 return false; 221 } 222 223 224 uint32_t 225 RegisterContext::NumSupportedHardwareWatchpoints () 226 { 227 return 0; 228 } 229 230 uint32_t 231 RegisterContext::SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write) 232 { 233 return LLDB_INVALID_INDEX32; 234 } 235 236 bool 237 RegisterContext::ClearHardwareWatchpoint (uint32_t hw_index) 238 { 239 return false; 240 } 241 242 bool 243 RegisterContext::HardwareSingleStep (bool enable) 244 { 245 return false; 246 } 247 248 Error 249 RegisterContext::ReadRegisterValueFromMemory (const RegisterInfo *reg_info, 250 lldb::addr_t src_addr, 251 uint32_t src_len, 252 RegisterValue ®_value) 253 { 254 Error error; 255 if (reg_info == NULL) 256 { 257 error.SetErrorString ("invalid register info argument."); 258 return error; 259 } 260 261 262 // Moving from addr into a register 263 // 264 // Case 1: src_len == dst_len 265 // 266 // |AABBCCDD| Address contents 267 // |AABBCCDD| Register contents 268 // 269 // Case 2: src_len > dst_len 270 // 271 // Error! (The register should always be big enough to hold the data) 272 // 273 // Case 3: src_len < dst_len 274 // 275 // |AABB| Address contents 276 // |AABB0000| Register contents [on little-endian hardware] 277 // |0000AABB| Register contents [on big-endian hardware] 278 if (src_len > RegisterValue::kMaxRegisterByteSize) 279 { 280 error.SetErrorString ("register too small to receive memory data"); 281 return error; 282 } 283 284 const uint32_t dst_len = reg_info->byte_size; 285 286 if (src_len > dst_len) 287 { 288 error.SetErrorStringWithFormat("%u bytes is too big to store in register %s (%u bytes)", src_len, reg_info->name, dst_len); 289 return error; 290 } 291 292 ProcessSP process_sp (m_thread.GetProcess()); 293 if (process_sp) 294 { 295 uint8_t src[RegisterValue::kMaxRegisterByteSize]; 296 297 // Read the memory 298 const uint32_t bytes_read = process_sp->ReadMemory (src_addr, src, src_len, error); 299 300 // Make sure the memory read succeeded... 301 if (bytes_read != src_len) 302 { 303 if (error.Success()) 304 { 305 // This might happen if we read _some_ bytes but not all 306 error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read, src_len); 307 } 308 return error; 309 } 310 311 // We now have a memory buffer that contains the part or all of the register 312 // value. Set the register value using this memory data. 313 // TODO: we might need to add a parameter to this function in case the byte 314 // order of the memory data doesn't match the process. For now we are assuming 315 // they are the same. 316 reg_value.SetFromMemoryData (reg_info, 317 src, 318 src_len, 319 process_sp->GetByteOrder(), 320 error); 321 } 322 else 323 error.SetErrorString("invalid process"); 324 325 return error; 326 } 327 328 Error 329 RegisterContext::WriteRegisterValueToMemory (const RegisterInfo *reg_info, 330 lldb::addr_t dst_addr, 331 uint32_t dst_len, 332 const RegisterValue ®_value) 333 { 334 335 uint8_t dst[RegisterValue::kMaxRegisterByteSize]; 336 337 Error error; 338 339 ProcessSP process_sp (m_thread.GetProcess()); 340 if (process_sp) 341 { 342 343 // TODO: we might need to add a parameter to this function in case the byte 344 // order of the memory data doesn't match the process. For now we are assuming 345 // they are the same. 346 347 const uint32_t bytes_copied = reg_value.GetAsMemoryData (reg_info, 348 dst, 349 dst_len, 350 process_sp->GetByteOrder(), 351 error); 352 353 if (error.Success()) 354 { 355 if (bytes_copied == 0) 356 { 357 error.SetErrorString("byte copy failed."); 358 } 359 else 360 { 361 const uint32_t bytes_written = process_sp->WriteMemory (dst_addr, dst, bytes_copied, error); 362 if (bytes_written != bytes_copied) 363 { 364 if (error.Success()) 365 { 366 // This might happen if we read _some_ bytes but not all 367 error.SetErrorStringWithFormat("only wrote %u of %u bytes", bytes_written, bytes_copied); 368 } 369 } 370 } 371 } 372 } 373 else 374 error.SetErrorString("invalid process"); 375 376 return error; 377 378 } 379 380 TargetSP 381 RegisterContext::CalculateTarget () 382 { 383 return m_thread.CalculateTarget(); 384 } 385 386 387 ProcessSP 388 RegisterContext::CalculateProcess () 389 { 390 return m_thread.CalculateProcess (); 391 } 392 393 ThreadSP 394 RegisterContext::CalculateThread () 395 { 396 return m_thread.shared_from_this(); 397 } 398 399 StackFrameSP 400 RegisterContext::CalculateStackFrame () 401 { 402 // Register contexts might belong to many frames if we have inlined 403 // functions inside a frame since all inlined functions share the 404 // same registers, so we can't definitively say which frame we come from... 405 return StackFrameSP(); 406 } 407 408 void 409 RegisterContext::CalculateExecutionContext (ExecutionContext &exe_ctx) 410 { 411 m_thread.CalculateExecutionContext (exe_ctx); 412 } 413 414 415 bool 416 RegisterContext::ConvertBetweenRegisterKinds (int source_rk, uint32_t source_regnum, int target_rk, uint32_t& target_regnum) 417 { 418 const uint32_t num_registers = GetRegisterCount(); 419 for (uint32_t reg = 0; reg < num_registers; ++reg) 420 { 421 const RegisterInfo * reg_info = GetRegisterInfoAtIndex (reg); 422 423 if (reg_info->kinds[source_rk] == source_regnum) 424 { 425 target_regnum = reg_info->kinds[target_rk]; 426 if (target_regnum == LLDB_INVALID_REGNUM) 427 { 428 return false; 429 } 430 else 431 { 432 return true; 433 } 434 } 435 } 436 return false; 437 } 438 439 //bool 440 //RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value) 441 //{ 442 // DataExtractor data; 443 // if (!ReadRegisterBytes (reg, data)) 444 // return false; 445 // 446 // const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg); 447 // uint32_t offset = 0; 448 // switch (reg_info->encoding) 449 // { 450 // case eEncodingInvalid: 451 // case eEncodingVector: 452 // break; 453 // 454 // case eEncodingUint: 455 // switch (reg_info->byte_size) 456 // { 457 // case 1: 458 // { 459 // value = data.GetU8 (&offset); 460 // return true; 461 // } 462 // case 2: 463 // { 464 // value = data.GetU16 (&offset); 465 // return true; 466 // } 467 // case 4: 468 // { 469 // value = data.GetU32 (&offset); 470 // return true; 471 // } 472 // case 8: 473 // { 474 // value = data.GetU64 (&offset); 475 // return true; 476 // } 477 // } 478 // break; 479 // case eEncodingSint: 480 // switch (reg_info->byte_size) 481 // { 482 // case 1: 483 // { 484 // int8_t v; 485 // if (data.ExtractBytes (0, sizeof (int8_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int8_t)) 486 // return false; 487 // value = v; 488 // return true; 489 // } 490 // case 2: 491 // { 492 // int16_t v; 493 // if (data.ExtractBytes (0, sizeof (int16_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int16_t)) 494 // return false; 495 // value = v; 496 // return true; 497 // } 498 // case 4: 499 // { 500 // int32_t v; 501 // if (data.ExtractBytes (0, sizeof (int32_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int32_t)) 502 // return false; 503 // value = v; 504 // return true; 505 // } 506 // case 8: 507 // { 508 // int64_t v; 509 // if (data.ExtractBytes (0, sizeof (int64_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int64_t)) 510 // return false; 511 // value = v; 512 // return true; 513 // } 514 // } 515 // break; 516 // case eEncodingIEEE754: 517 // switch (reg_info->byte_size) 518 // { 519 // case sizeof (float): 520 // { 521 // float v; 522 // if (data.ExtractBytes (0, sizeof (float), lldb::endian::InlHostByteOrder(), &v) != sizeof (float)) 523 // return false; 524 // value = v; 525 // return true; 526 // } 527 // case sizeof (double): 528 // { 529 // double v; 530 // if (data.ExtractBytes (0, sizeof (double), lldb::endian::InlHostByteOrder(), &v) != sizeof (double)) 531 // return false; 532 // value = v; 533 // return true; 534 // } 535 // case sizeof (long double): 536 // { 537 // double v; 538 // if (data.ExtractBytes (0, sizeof (long double), lldb::endian::InlHostByteOrder(), &v) != sizeof (long double)) 539 // return false; 540 // value = v; 541 // return true; 542 // } 543 // } 544 // break; 545 // } 546 // return false; 547 //} 548 // 549 //bool 550 //RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value) 551 //{ 552 // DataExtractor data; 553 // if (!value.IsValid()) 554 // return false; 555 // if (!value.GetData (data)) 556 // return false; 557 // 558 // return WriteRegisterBytes (reg, data); 559 //} 560