1 //===-- RegisterContextThreadMemory.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 "lldb/lldb-private.h" 11 #include "lldb/Core/Error.h" 12 #include "lldb/Target/OperatingSystem.h" 13 #include "lldb/Target/Process.h" 14 #include "lldb/Target/Thread.h" 15 16 #include "RegisterContextThreadMemory.h" 17 18 using namespace lldb; 19 using namespace lldb_private; 20 21 RegisterContextThreadMemory::RegisterContextThreadMemory (Thread &thread, 22 lldb::addr_t register_data_addr) : 23 RegisterContext (thread, 0), 24 m_thread_wp (thread.shared_from_this()), 25 m_reg_ctx_sp (), 26 m_register_data_addr (register_data_addr), 27 m_stop_id(0) 28 { 29 } 30 31 RegisterContextThreadMemory::~RegisterContextThreadMemory() 32 { 33 } 34 35 void 36 RegisterContextThreadMemory::UpdateRegisterContext () 37 { 38 ThreadSP thread_sp (m_thread_wp.lock()); 39 if (thread_sp) 40 { 41 ProcessSP process_sp (thread_sp->GetProcess()); 42 43 if (process_sp) 44 { 45 const uint32_t stop_id = process_sp->GetModID().GetStopID(); 46 if (m_stop_id != stop_id) 47 { 48 m_stop_id = stop_id; 49 m_reg_ctx_sp.reset(); 50 } 51 if (!m_reg_ctx_sp) 52 { 53 ThreadSP backing_thread_sp (thread_sp->GetBackingThread()); 54 if (backing_thread_sp) 55 { 56 m_reg_ctx_sp = backing_thread_sp->GetRegisterContext(); 57 } 58 else 59 { 60 OperatingSystem *os = process_sp->GetOperatingSystem (); 61 if (os->IsOperatingSystemPluginThread (thread_sp)) 62 m_reg_ctx_sp = os->CreateRegisterContextForThread (thread_sp.get(), LLDB_INVALID_ADDRESS); 63 } 64 } 65 } 66 else 67 { 68 m_reg_ctx_sp.reset(); 69 } 70 } 71 else 72 { 73 m_reg_ctx_sp.reset(); 74 } 75 } 76 77 //------------------------------------------------------------------ 78 // Subclasses must override these functions 79 //------------------------------------------------------------------ 80 void 81 RegisterContextThreadMemory::InvalidateAllRegisters () 82 { 83 UpdateRegisterContext (); 84 if (m_reg_ctx_sp) 85 m_reg_ctx_sp->InvalidateAllRegisters(); 86 } 87 88 size_t 89 RegisterContextThreadMemory::GetRegisterCount () 90 { 91 UpdateRegisterContext (); 92 if (m_reg_ctx_sp) 93 return m_reg_ctx_sp->GetRegisterCount(); 94 return 0; 95 } 96 97 const RegisterInfo * 98 RegisterContextThreadMemory::GetRegisterInfoAtIndex (size_t reg) 99 { 100 UpdateRegisterContext (); 101 if (m_reg_ctx_sp) 102 return m_reg_ctx_sp->GetRegisterInfoAtIndex(reg); 103 return NULL; 104 } 105 106 size_t 107 RegisterContextThreadMemory::GetRegisterSetCount () 108 { 109 UpdateRegisterContext (); 110 if (m_reg_ctx_sp) 111 return m_reg_ctx_sp->GetRegisterSetCount(); 112 return 0; 113 } 114 115 const RegisterSet * 116 RegisterContextThreadMemory::GetRegisterSet (size_t reg_set) 117 { 118 UpdateRegisterContext (); 119 if (m_reg_ctx_sp) 120 return m_reg_ctx_sp->GetRegisterSet(reg_set); 121 return NULL; 122 } 123 124 bool 125 RegisterContextThreadMemory::ReadRegister (const RegisterInfo *reg_info, RegisterValue ®_value) 126 { 127 UpdateRegisterContext (); 128 if (m_reg_ctx_sp) 129 return m_reg_ctx_sp->ReadRegister(reg_info, reg_value); 130 return false; 131 } 132 133 bool 134 RegisterContextThreadMemory::WriteRegister (const RegisterInfo *reg_info, const RegisterValue ®_value) 135 { 136 UpdateRegisterContext (); 137 if (m_reg_ctx_sp) 138 return m_reg_ctx_sp->WriteRegister (reg_info, reg_value); 139 return false; 140 } 141 142 bool 143 RegisterContextThreadMemory::ReadAllRegisterValues (lldb::DataBufferSP &data_sp) 144 { 145 UpdateRegisterContext (); 146 if (m_reg_ctx_sp) 147 return m_reg_ctx_sp->ReadAllRegisterValues(data_sp); 148 return false; 149 } 150 151 bool 152 RegisterContextThreadMemory::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp) 153 { 154 UpdateRegisterContext (); 155 if (m_reg_ctx_sp) 156 return m_reg_ctx_sp->WriteAllRegisterValues (data_sp); 157 return false; 158 } 159 160 bool 161 RegisterContextThreadMemory::CopyFromRegisterContext (lldb::RegisterContextSP reg_ctx_sp) 162 { 163 UpdateRegisterContext (); 164 if (m_reg_ctx_sp) 165 return m_reg_ctx_sp->CopyFromRegisterContext(reg_ctx_sp); 166 return false; 167 } 168 169 uint32_t 170 RegisterContextThreadMemory::ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num) 171 { 172 UpdateRegisterContext (); 173 if (m_reg_ctx_sp) 174 return m_reg_ctx_sp->ConvertRegisterKindToRegisterNumber(kind, num); 175 return false; 176 } 177 178 uint32_t 179 RegisterContextThreadMemory::NumSupportedHardwareBreakpoints () 180 { 181 UpdateRegisterContext (); 182 if (m_reg_ctx_sp) 183 return m_reg_ctx_sp->NumSupportedHardwareBreakpoints(); 184 return false; 185 } 186 187 uint32_t 188 RegisterContextThreadMemory::SetHardwareBreakpoint (lldb::addr_t addr, size_t size) 189 { 190 UpdateRegisterContext (); 191 if (m_reg_ctx_sp) 192 return m_reg_ctx_sp->SetHardwareBreakpoint(addr, size); 193 return 0; 194 } 195 196 bool 197 RegisterContextThreadMemory::ClearHardwareBreakpoint (uint32_t hw_idx) 198 { 199 UpdateRegisterContext (); 200 if (m_reg_ctx_sp) 201 return m_reg_ctx_sp->ClearHardwareBreakpoint (hw_idx); 202 return false; 203 } 204 205 uint32_t 206 RegisterContextThreadMemory::NumSupportedHardwareWatchpoints () 207 { 208 UpdateRegisterContext (); 209 if (m_reg_ctx_sp) 210 return m_reg_ctx_sp->NumSupportedHardwareWatchpoints(); 211 return 0; 212 } 213 214 uint32_t 215 RegisterContextThreadMemory::SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write) 216 { 217 UpdateRegisterContext (); 218 if (m_reg_ctx_sp) 219 return m_reg_ctx_sp->SetHardwareWatchpoint(addr, size, read, write); 220 return 0; 221 } 222 223 bool 224 RegisterContextThreadMemory::ClearHardwareWatchpoint (uint32_t hw_index) 225 { 226 UpdateRegisterContext (); 227 if (m_reg_ctx_sp) 228 return m_reg_ctx_sp->ClearHardwareWatchpoint(hw_index); 229 return false; 230 } 231 232 bool 233 RegisterContextThreadMemory::HardwareSingleStep (bool enable) 234 { 235 UpdateRegisterContext (); 236 if (m_reg_ctx_sp) 237 return m_reg_ctx_sp->HardwareSingleStep(enable); 238 return false; 239 } 240 241 Error 242 RegisterContextThreadMemory::ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len, RegisterValue ®_value) 243 { 244 UpdateRegisterContext (); 245 if (m_reg_ctx_sp) 246 return m_reg_ctx_sp->ReadRegisterValueFromMemory (reg_info, src_addr, src_len, reg_value); 247 Error error; 248 error.SetErrorString("invalid register context"); 249 return error; 250 } 251 252 Error 253 RegisterContextThreadMemory::WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len, const RegisterValue ®_value) 254 { 255 UpdateRegisterContext (); 256 if (m_reg_ctx_sp) 257 return m_reg_ctx_sp->WriteRegisterValueToMemory (reg_info, dst_addr, dst_len, reg_value); 258 Error error; 259 error.SetErrorString("invalid register context"); 260 return error; 261 } 262
