RegisterContext.cpp revision 254721
1254721Semaste//===-- RegisterContext.cpp -------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste// C Includes 11254721Semaste// C++ Includes 12254721Semaste// Other libraries and framework includes 13254721Semaste// Project includes 14254721Semaste#include "lldb/Target/RegisterContext.h" 15254721Semaste#include "lldb/Core/DataExtractor.h" 16254721Semaste#include "lldb/Core/RegisterValue.h" 17254721Semaste#include "lldb/Core/Scalar.h" 18254721Semaste#include "lldb/Host/Endian.h" 19254721Semaste#include "lldb/Target/ExecutionContext.h" 20254721Semaste#include "lldb/Target/StackFrame.h" 21254721Semaste#include "lldb/Target/Process.h" 22254721Semaste#include "lldb/Target/Thread.h" 23254721Semaste 24254721Semasteusing namespace lldb; 25254721Semasteusing namespace lldb_private; 26254721Semaste 27254721SemasteRegisterContext::RegisterContext (Thread &thread, uint32_t concrete_frame_idx) : 28254721Semaste m_thread (thread), 29254721Semaste m_concrete_frame_idx (concrete_frame_idx), 30254721Semaste m_stop_id (thread.GetProcess()->GetStopID()) 31254721Semaste{ 32254721Semaste} 33254721Semaste 34254721Semaste//---------------------------------------------------------------------- 35254721Semaste// Destructor 36254721Semaste//---------------------------------------------------------------------- 37254721SemasteRegisterContext::~RegisterContext() 38254721Semaste{ 39254721Semaste} 40254721Semaste 41254721Semastevoid 42254721SemasteRegisterContext::InvalidateIfNeeded (bool force) 43254721Semaste{ 44254721Semaste ProcessSP process_sp (m_thread.GetProcess()); 45254721Semaste bool invalidate = force; 46254721Semaste uint32_t process_stop_id = UINT32_MAX; 47254721Semaste 48254721Semaste if (process_sp) 49254721Semaste process_stop_id = process_sp->GetStopID(); 50254721Semaste else 51254721Semaste invalidate = true; 52254721Semaste 53254721Semaste if (!invalidate) 54254721Semaste invalidate = process_stop_id != GetStopID(); 55254721Semaste 56254721Semaste if (invalidate) 57254721Semaste { 58254721Semaste InvalidateAllRegisters (); 59254721Semaste SetStopID (process_stop_id); 60254721Semaste } 61254721Semaste} 62254721Semaste 63254721Semaste 64254721Semasteconst RegisterInfo * 65254721SemasteRegisterContext::GetRegisterInfoByName (const char *reg_name, uint32_t start_idx) 66254721Semaste{ 67254721Semaste if (reg_name && reg_name[0]) 68254721Semaste { 69254721Semaste const uint32_t num_registers = GetRegisterCount(); 70254721Semaste for (uint32_t reg = start_idx; reg < num_registers; ++reg) 71254721Semaste { 72254721Semaste const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); 73254721Semaste 74254721Semaste if ((reg_info->name != NULL && ::strcasecmp (reg_info->name, reg_name) == 0) || 75254721Semaste (reg_info->alt_name != NULL && ::strcasecmp (reg_info->alt_name, reg_name) == 0)) 76254721Semaste { 77254721Semaste return reg_info; 78254721Semaste } 79254721Semaste } 80254721Semaste } 81254721Semaste return NULL; 82254721Semaste} 83254721Semaste 84254721Semasteconst char * 85254721SemasteRegisterContext::GetRegisterName (uint32_t reg) 86254721Semaste{ 87254721Semaste const RegisterInfo * reg_info = GetRegisterInfoAtIndex(reg); 88254721Semaste if (reg_info) 89254721Semaste return reg_info->name; 90254721Semaste return NULL; 91254721Semaste} 92254721Semaste 93254721Semasteuint64_t 94254721SemasteRegisterContext::GetPC(uint64_t fail_value) 95254721Semaste{ 96254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 97254721Semaste return ReadRegisterAsUnsigned (reg, fail_value); 98254721Semaste} 99254721Semaste 100254721Semastebool 101254721SemasteRegisterContext::SetPC(uint64_t pc) 102254721Semaste{ 103254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 104254721Semaste bool success = WriteRegisterFromUnsigned (reg, pc); 105254721Semaste if (success) 106254721Semaste { 107254721Semaste StackFrameSP frame_sp(m_thread.GetFrameWithConcreteFrameIndex (m_concrete_frame_idx)); 108254721Semaste if (frame_sp) 109254721Semaste frame_sp->ChangePC(pc); 110254721Semaste else 111254721Semaste m_thread.ClearStackFrames (); 112254721Semaste } 113254721Semaste return success; 114254721Semaste} 115254721Semaste 116254721Semasteuint64_t 117254721SemasteRegisterContext::GetSP(uint64_t fail_value) 118254721Semaste{ 119254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 120254721Semaste return ReadRegisterAsUnsigned (reg, fail_value); 121254721Semaste} 122254721Semaste 123254721Semastebool 124254721SemasteRegisterContext::SetSP(uint64_t sp) 125254721Semaste{ 126254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP); 127254721Semaste return WriteRegisterFromUnsigned (reg, sp); 128254721Semaste} 129254721Semaste 130254721Semasteuint64_t 131254721SemasteRegisterContext::GetFP(uint64_t fail_value) 132254721Semaste{ 133254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); 134254721Semaste return ReadRegisterAsUnsigned (reg, fail_value); 135254721Semaste} 136254721Semaste 137254721Semastebool 138254721SemasteRegisterContext::SetFP(uint64_t fp) 139254721Semaste{ 140254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP); 141254721Semaste return WriteRegisterFromUnsigned (reg, fp); 142254721Semaste} 143254721Semaste 144254721Semasteuint64_t 145254721SemasteRegisterContext::GetReturnAddress (uint64_t fail_value) 146254721Semaste{ 147254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA); 148254721Semaste return ReadRegisterAsUnsigned (reg, fail_value); 149254721Semaste} 150254721Semaste 151254721Semasteuint64_t 152254721SemasteRegisterContext::GetFlags (uint64_t fail_value) 153254721Semaste{ 154254721Semaste uint32_t reg = ConvertRegisterKindToRegisterNumber (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS); 155254721Semaste return ReadRegisterAsUnsigned (reg, fail_value); 156254721Semaste} 157254721Semaste 158254721Semaste 159254721Semasteuint64_t 160254721SemasteRegisterContext::ReadRegisterAsUnsigned (uint32_t reg, uint64_t fail_value) 161254721Semaste{ 162254721Semaste if (reg != LLDB_INVALID_REGNUM) 163254721Semaste return ReadRegisterAsUnsigned (GetRegisterInfoAtIndex (reg), fail_value); 164254721Semaste return fail_value; 165254721Semaste} 166254721Semaste 167254721Semasteuint64_t 168254721SemasteRegisterContext::ReadRegisterAsUnsigned (const RegisterInfo *reg_info, uint64_t fail_value) 169254721Semaste{ 170254721Semaste if (reg_info) 171254721Semaste { 172254721Semaste RegisterValue value; 173254721Semaste if (ReadRegister (reg_info, value)) 174254721Semaste return value.GetAsUInt64(); 175254721Semaste } 176254721Semaste return fail_value; 177254721Semaste} 178254721Semaste 179254721Semastebool 180254721SemasteRegisterContext::WriteRegisterFromUnsigned (uint32_t reg, uint64_t uval) 181254721Semaste{ 182254721Semaste if (reg == LLDB_INVALID_REGNUM) 183254721Semaste return false; 184254721Semaste return WriteRegisterFromUnsigned (GetRegisterInfoAtIndex (reg), uval); 185254721Semaste} 186254721Semaste 187254721Semastebool 188254721SemasteRegisterContext::WriteRegisterFromUnsigned (const RegisterInfo *reg_info, uint64_t uval) 189254721Semaste{ 190254721Semaste if (reg_info) 191254721Semaste { 192254721Semaste RegisterValue value; 193254721Semaste if (value.SetUInt(uval, reg_info->byte_size)) 194254721Semaste return WriteRegister (reg_info, value); 195254721Semaste } 196254721Semaste return false; 197254721Semaste} 198254721Semaste 199254721Semastebool 200254721SemasteRegisterContext::CopyFromRegisterContext (lldb::RegisterContextSP context) 201254721Semaste{ 202254721Semaste uint32_t num_register_sets = context->GetRegisterSetCount(); 203254721Semaste // We don't know that two threads have the same register context, so require the threads to be the same. 204254721Semaste if (context->GetThreadID() != GetThreadID()) 205254721Semaste return false; 206254721Semaste 207254721Semaste if (num_register_sets != GetRegisterSetCount()) 208254721Semaste return false; 209254721Semaste 210254721Semaste RegisterContextSP frame_zero_context = m_thread.GetRegisterContext(); 211254721Semaste 212254721Semaste for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) 213254721Semaste { 214254721Semaste const RegisterSet * const reg_set = GetRegisterSet(set_idx); 215254721Semaste 216254721Semaste const uint32_t num_registers = reg_set->num_registers; 217254721Semaste for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) 218254721Semaste { 219254721Semaste const uint32_t reg = reg_set->registers[reg_idx]; 220254721Semaste const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg); 221254721Semaste if (!reg_info || reg_info->value_regs) 222254721Semaste continue; 223254721Semaste RegisterValue reg_value; 224254721Semaste 225254721Semaste // If we can reconstruct the register from the frame we are copying from, then do so, otherwise 226254721Semaste // use the value from frame 0. 227254721Semaste if (context->ReadRegister(reg_info, reg_value)) 228254721Semaste { 229254721Semaste WriteRegister(reg_info, reg_value); 230254721Semaste } 231254721Semaste else if (frame_zero_context->ReadRegister(reg_info, reg_value)) 232254721Semaste { 233254721Semaste WriteRegister(reg_info, reg_value); 234254721Semaste } 235254721Semaste } 236254721Semaste } 237254721Semaste return true; 238254721Semaste} 239254721Semaste 240254721Semastelldb::tid_t 241254721SemasteRegisterContext::GetThreadID() const 242254721Semaste{ 243254721Semaste return m_thread.GetID(); 244254721Semaste} 245254721Semaste 246254721Semasteuint32_t 247254721SemasteRegisterContext::NumSupportedHardwareBreakpoints () 248254721Semaste{ 249254721Semaste return 0; 250254721Semaste} 251254721Semaste 252254721Semasteuint32_t 253254721SemasteRegisterContext::SetHardwareBreakpoint (lldb::addr_t addr, size_t size) 254254721Semaste{ 255254721Semaste return LLDB_INVALID_INDEX32; 256254721Semaste} 257254721Semaste 258254721Semastebool 259254721SemasteRegisterContext::ClearHardwareBreakpoint (uint32_t hw_idx) 260254721Semaste{ 261254721Semaste return false; 262254721Semaste} 263254721Semaste 264254721Semaste 265254721Semasteuint32_t 266254721SemasteRegisterContext::NumSupportedHardwareWatchpoints () 267254721Semaste{ 268254721Semaste return 0; 269254721Semaste} 270254721Semaste 271254721Semasteuint32_t 272254721SemasteRegisterContext::SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write) 273254721Semaste{ 274254721Semaste return LLDB_INVALID_INDEX32; 275254721Semaste} 276254721Semaste 277254721Semastebool 278254721SemasteRegisterContext::ClearHardwareWatchpoint (uint32_t hw_index) 279254721Semaste{ 280254721Semaste return false; 281254721Semaste} 282254721Semaste 283254721Semastebool 284254721SemasteRegisterContext::HardwareSingleStep (bool enable) 285254721Semaste{ 286254721Semaste return false; 287254721Semaste} 288254721Semaste 289254721SemasteError 290254721SemasteRegisterContext::ReadRegisterValueFromMemory (const RegisterInfo *reg_info, 291254721Semaste lldb::addr_t src_addr, 292254721Semaste uint32_t src_len, 293254721Semaste RegisterValue ®_value) 294254721Semaste{ 295254721Semaste Error error; 296254721Semaste if (reg_info == NULL) 297254721Semaste { 298254721Semaste error.SetErrorString ("invalid register info argument."); 299254721Semaste return error; 300254721Semaste } 301254721Semaste 302254721Semaste 303254721Semaste // Moving from addr into a register 304254721Semaste // 305254721Semaste // Case 1: src_len == dst_len 306254721Semaste // 307254721Semaste // |AABBCCDD| Address contents 308254721Semaste // |AABBCCDD| Register contents 309254721Semaste // 310254721Semaste // Case 2: src_len > dst_len 311254721Semaste // 312254721Semaste // Error! (The register should always be big enough to hold the data) 313254721Semaste // 314254721Semaste // Case 3: src_len < dst_len 315254721Semaste // 316254721Semaste // |AABB| Address contents 317254721Semaste // |AABB0000| Register contents [on little-endian hardware] 318254721Semaste // |0000AABB| Register contents [on big-endian hardware] 319254721Semaste if (src_len > RegisterValue::kMaxRegisterByteSize) 320254721Semaste { 321254721Semaste error.SetErrorString ("register too small to receive memory data"); 322254721Semaste return error; 323254721Semaste } 324254721Semaste 325254721Semaste const uint32_t dst_len = reg_info->byte_size; 326254721Semaste 327254721Semaste if (src_len > dst_len) 328254721Semaste { 329254721Semaste error.SetErrorStringWithFormat("%u bytes is too big to store in register %s (%u bytes)", src_len, reg_info->name, dst_len); 330254721Semaste return error; 331254721Semaste } 332254721Semaste 333254721Semaste ProcessSP process_sp (m_thread.GetProcess()); 334254721Semaste if (process_sp) 335254721Semaste { 336254721Semaste uint8_t src[RegisterValue::kMaxRegisterByteSize]; 337254721Semaste 338254721Semaste // Read the memory 339254721Semaste const uint32_t bytes_read = process_sp->ReadMemory (src_addr, src, src_len, error); 340254721Semaste 341254721Semaste // Make sure the memory read succeeded... 342254721Semaste if (bytes_read != src_len) 343254721Semaste { 344254721Semaste if (error.Success()) 345254721Semaste { 346254721Semaste // This might happen if we read _some_ bytes but not all 347254721Semaste error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read, src_len); 348254721Semaste } 349254721Semaste return error; 350254721Semaste } 351254721Semaste 352254721Semaste // We now have a memory buffer that contains the part or all of the register 353254721Semaste // value. Set the register value using this memory data. 354254721Semaste // TODO: we might need to add a parameter to this function in case the byte 355254721Semaste // order of the memory data doesn't match the process. For now we are assuming 356254721Semaste // they are the same. 357254721Semaste reg_value.SetFromMemoryData (reg_info, 358254721Semaste src, 359254721Semaste src_len, 360254721Semaste process_sp->GetByteOrder(), 361254721Semaste error); 362254721Semaste } 363254721Semaste else 364254721Semaste error.SetErrorString("invalid process"); 365254721Semaste 366254721Semaste return error; 367254721Semaste} 368254721Semaste 369254721SemasteError 370254721SemasteRegisterContext::WriteRegisterValueToMemory (const RegisterInfo *reg_info, 371254721Semaste lldb::addr_t dst_addr, 372254721Semaste uint32_t dst_len, 373254721Semaste const RegisterValue ®_value) 374254721Semaste{ 375254721Semaste 376254721Semaste uint8_t dst[RegisterValue::kMaxRegisterByteSize]; 377254721Semaste 378254721Semaste Error error; 379254721Semaste 380254721Semaste ProcessSP process_sp (m_thread.GetProcess()); 381254721Semaste if (process_sp) 382254721Semaste { 383254721Semaste 384254721Semaste // TODO: we might need to add a parameter to this function in case the byte 385254721Semaste // order of the memory data doesn't match the process. For now we are assuming 386254721Semaste // they are the same. 387254721Semaste 388254721Semaste const uint32_t bytes_copied = reg_value.GetAsMemoryData (reg_info, 389254721Semaste dst, 390254721Semaste dst_len, 391254721Semaste process_sp->GetByteOrder(), 392254721Semaste error); 393254721Semaste 394254721Semaste if (error.Success()) 395254721Semaste { 396254721Semaste if (bytes_copied == 0) 397254721Semaste { 398254721Semaste error.SetErrorString("byte copy failed."); 399254721Semaste } 400254721Semaste else 401254721Semaste { 402254721Semaste const uint32_t bytes_written = process_sp->WriteMemory (dst_addr, dst, bytes_copied, error); 403254721Semaste if (bytes_written != bytes_copied) 404254721Semaste { 405254721Semaste if (error.Success()) 406254721Semaste { 407254721Semaste // This might happen if we read _some_ bytes but not all 408254721Semaste error.SetErrorStringWithFormat("only wrote %u of %u bytes", bytes_written, bytes_copied); 409254721Semaste } 410254721Semaste } 411254721Semaste } 412254721Semaste } 413254721Semaste } 414254721Semaste else 415254721Semaste error.SetErrorString("invalid process"); 416254721Semaste 417254721Semaste return error; 418254721Semaste 419254721Semaste} 420254721Semaste 421254721SemasteTargetSP 422254721SemasteRegisterContext::CalculateTarget () 423254721Semaste{ 424254721Semaste return m_thread.CalculateTarget(); 425254721Semaste} 426254721Semaste 427254721Semaste 428254721SemasteProcessSP 429254721SemasteRegisterContext::CalculateProcess () 430254721Semaste{ 431254721Semaste return m_thread.CalculateProcess (); 432254721Semaste} 433254721Semaste 434254721SemasteThreadSP 435254721SemasteRegisterContext::CalculateThread () 436254721Semaste{ 437254721Semaste return m_thread.shared_from_this(); 438254721Semaste} 439254721Semaste 440254721SemasteStackFrameSP 441254721SemasteRegisterContext::CalculateStackFrame () 442254721Semaste{ 443254721Semaste // Register contexts might belong to many frames if we have inlined 444254721Semaste // functions inside a frame since all inlined functions share the 445254721Semaste // same registers, so we can't definitively say which frame we come from... 446254721Semaste return StackFrameSP(); 447254721Semaste} 448254721Semaste 449254721Semastevoid 450254721SemasteRegisterContext::CalculateExecutionContext (ExecutionContext &exe_ctx) 451254721Semaste{ 452254721Semaste m_thread.CalculateExecutionContext (exe_ctx); 453254721Semaste} 454254721Semaste 455254721Semaste 456254721Semastebool 457254721SemasteRegisterContext::ConvertBetweenRegisterKinds (int source_rk, uint32_t source_regnum, int target_rk, uint32_t& target_regnum) 458254721Semaste{ 459254721Semaste const uint32_t num_registers = GetRegisterCount(); 460254721Semaste for (uint32_t reg = 0; reg < num_registers; ++reg) 461254721Semaste { 462254721Semaste const RegisterInfo * reg_info = GetRegisterInfoAtIndex (reg); 463254721Semaste 464254721Semaste if (reg_info->kinds[source_rk] == source_regnum) 465254721Semaste { 466254721Semaste target_regnum = reg_info->kinds[target_rk]; 467254721Semaste if (target_regnum == LLDB_INVALID_REGNUM) 468254721Semaste { 469254721Semaste return false; 470254721Semaste } 471254721Semaste else 472254721Semaste { 473254721Semaste return true; 474254721Semaste } 475254721Semaste } 476254721Semaste } 477254721Semaste return false; 478254721Semaste} 479254721Semaste 480254721Semaste//bool 481254721Semaste//RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value) 482254721Semaste//{ 483254721Semaste// DataExtractor data; 484254721Semaste// if (!ReadRegisterBytes (reg, data)) 485254721Semaste// return false; 486254721Semaste// 487254721Semaste// const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg); 488254721Semaste// uint32_t offset = 0; 489254721Semaste// switch (reg_info->encoding) 490254721Semaste// { 491254721Semaste// case eEncodingInvalid: 492254721Semaste// case eEncodingVector: 493254721Semaste// break; 494254721Semaste// 495254721Semaste// case eEncodingUint: 496254721Semaste// switch (reg_info->byte_size) 497254721Semaste// { 498254721Semaste// case 1: 499254721Semaste// { 500254721Semaste// value = data.GetU8 (&offset); 501254721Semaste// return true; 502254721Semaste// } 503254721Semaste// case 2: 504254721Semaste// { 505254721Semaste// value = data.GetU16 (&offset); 506254721Semaste// return true; 507254721Semaste// } 508254721Semaste// case 4: 509254721Semaste// { 510254721Semaste// value = data.GetU32 (&offset); 511254721Semaste// return true; 512254721Semaste// } 513254721Semaste// case 8: 514254721Semaste// { 515254721Semaste// value = data.GetU64 (&offset); 516254721Semaste// return true; 517254721Semaste// } 518254721Semaste// } 519254721Semaste// break; 520254721Semaste// case eEncodingSint: 521254721Semaste// switch (reg_info->byte_size) 522254721Semaste// { 523254721Semaste// case 1: 524254721Semaste// { 525254721Semaste// int8_t v; 526254721Semaste// if (data.ExtractBytes (0, sizeof (int8_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int8_t)) 527254721Semaste// return false; 528254721Semaste// value = v; 529254721Semaste// return true; 530254721Semaste// } 531254721Semaste// case 2: 532254721Semaste// { 533254721Semaste// int16_t v; 534254721Semaste// if (data.ExtractBytes (0, sizeof (int16_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int16_t)) 535254721Semaste// return false; 536254721Semaste// value = v; 537254721Semaste// return true; 538254721Semaste// } 539254721Semaste// case 4: 540254721Semaste// { 541254721Semaste// int32_t v; 542254721Semaste// if (data.ExtractBytes (0, sizeof (int32_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int32_t)) 543254721Semaste// return false; 544254721Semaste// value = v; 545254721Semaste// return true; 546254721Semaste// } 547254721Semaste// case 8: 548254721Semaste// { 549254721Semaste// int64_t v; 550254721Semaste// if (data.ExtractBytes (0, sizeof (int64_t), lldb::endian::InlHostByteOrder(), &v) != sizeof (int64_t)) 551254721Semaste// return false; 552254721Semaste// value = v; 553254721Semaste// return true; 554254721Semaste// } 555254721Semaste// } 556254721Semaste// break; 557254721Semaste// case eEncodingIEEE754: 558254721Semaste// switch (reg_info->byte_size) 559254721Semaste// { 560254721Semaste// case sizeof (float): 561254721Semaste// { 562254721Semaste// float v; 563254721Semaste// if (data.ExtractBytes (0, sizeof (float), lldb::endian::InlHostByteOrder(), &v) != sizeof (float)) 564254721Semaste// return false; 565254721Semaste// value = v; 566254721Semaste// return true; 567254721Semaste// } 568254721Semaste// case sizeof (double): 569254721Semaste// { 570254721Semaste// double v; 571254721Semaste// if (data.ExtractBytes (0, sizeof (double), lldb::endian::InlHostByteOrder(), &v) != sizeof (double)) 572254721Semaste// return false; 573254721Semaste// value = v; 574254721Semaste// return true; 575254721Semaste// } 576254721Semaste// case sizeof (long double): 577254721Semaste// { 578254721Semaste// double v; 579254721Semaste// if (data.ExtractBytes (0, sizeof (long double), lldb::endian::InlHostByteOrder(), &v) != sizeof (long double)) 580254721Semaste// return false; 581254721Semaste// value = v; 582254721Semaste// return true; 583254721Semaste// } 584254721Semaste// } 585254721Semaste// break; 586254721Semaste// } 587254721Semaste// return false; 588254721Semaste//} 589254721Semaste// 590254721Semaste//bool 591254721Semaste//RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value) 592254721Semaste//{ 593254721Semaste// DataExtractor data; 594254721Semaste// if (!value.IsValid()) 595254721Semaste// return false; 596254721Semaste// if (!value.GetData (data)) 597254721Semaste// return false; 598254721Semaste// 599254721Semaste// return WriteRegisterBytes (reg, data); 600254721Semaste//} 601