1 //===-- TargetThreadWindows.cpp--------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Host/HostInfo.h" 10 #include "lldb/Host/HostNativeThreadBase.h" 11 #include "lldb/Host/windows/HostThreadWindows.h" 12 #include "lldb/Host/windows/windows.h" 13 #include "lldb/Target/RegisterContext.h" 14 #include "lldb/Utility/Log.h" 15 #include "lldb/Utility/Logging.h" 16 #include "lldb/Utility/State.h" 17 18 #include "ProcessWindows.h" 19 #include "ProcessWindowsLog.h" 20 #include "TargetThreadWindows.h" 21 22 #if defined(__x86_64__) || defined(_M_AMD64) 23 #include "x64/RegisterContextWindows_x64.h" 24 #elif defined(__i386__) || defined(_M_IX86) 25 #include "x86/RegisterContextWindows_x86.h" 26 #elif defined(__aarch64__) || defined(_M_ARM64) 27 #include "arm64/RegisterContextWindows_arm64.h" 28 #elif defined(__arm__) || defined(_M_ARM) 29 #include "arm/RegisterContextWindows_arm.h" 30 #endif 31 32 using namespace lldb; 33 using namespace lldb_private; 34 35 TargetThreadWindows::TargetThreadWindows(ProcessWindows &process, 36 const HostThread &thread) 37 : Thread(process, thread.GetNativeThread().GetThreadId()), 38 m_thread_reg_ctx_sp(), m_host_thread(thread) {} 39 40 TargetThreadWindows::~TargetThreadWindows() { DestroyThread(); } 41 42 void TargetThreadWindows::RefreshStateAfterStop() { 43 ::SuspendThread(m_host_thread.GetNativeThread().GetSystemHandle()); 44 SetState(eStateStopped); 45 GetRegisterContext()->InvalidateIfNeeded(false); 46 } 47 48 void TargetThreadWindows::WillResume(lldb::StateType resume_state) {} 49 50 void TargetThreadWindows::DidStop() {} 51 52 RegisterContextSP TargetThreadWindows::GetRegisterContext() { 53 if (!m_reg_context_sp) 54 m_reg_context_sp = CreateRegisterContextForFrame(nullptr); 55 56 return m_reg_context_sp; 57 } 58 59 RegisterContextSP 60 TargetThreadWindows::CreateRegisterContextForFrame(StackFrame *frame) { 61 RegisterContextSP reg_ctx_sp; 62 uint32_t concrete_frame_idx = 0; 63 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD)); 64 65 if (frame) 66 concrete_frame_idx = frame->GetConcreteFrameIndex(); 67 68 if (concrete_frame_idx == 0) { 69 if (!m_thread_reg_ctx_sp) { 70 ArchSpec arch = HostInfo::GetArchitecture(); 71 switch (arch.GetMachine()) { 72 case llvm::Triple::arm: 73 case llvm::Triple::thumb: 74 #if defined(__arm__) || defined(_M_ARM) 75 m_thread_reg_ctx_sp.reset( 76 new RegisterContextWindows_arm(*this, concrete_frame_idx)); 77 #else 78 LLDB_LOG(log, "debugging foreign targets is currently unsupported"); 79 #endif 80 break; 81 82 case llvm::Triple::aarch64: 83 #if defined(__aarch64__) || defined(_M_ARM64) 84 m_thread_reg_ctx_sp.reset( 85 new RegisterContextWindows_arm64(*this, concrete_frame_idx)); 86 #else 87 LLDB_LOG(log, "debugging foreign targets is currently unsupported"); 88 #endif 89 break; 90 91 case llvm::Triple::x86: 92 #if defined(__i386__) || defined(_M_IX86) 93 m_thread_reg_ctx_sp.reset( 94 new RegisterContextWindows_x86(*this, concrete_frame_idx)); 95 #else 96 LLDB_LOG(log, "debugging foreign targets is currently unsupported"); 97 #endif 98 break; 99 100 case llvm::Triple::x86_64: 101 #if defined(__x86_64__) || defined(_M_AMD64) 102 m_thread_reg_ctx_sp.reset( 103 new RegisterContextWindows_x64(*this, concrete_frame_idx)); 104 #else 105 LLDB_LOG(log, "debugging foreign targets is currently unsupported"); 106 #endif 107 break; 108 109 default: 110 break; 111 } 112 } 113 reg_ctx_sp = m_thread_reg_ctx_sp; 114 } else { 115 reg_ctx_sp = GetUnwinder().CreateRegisterContextForFrame(frame); 116 } 117 118 return reg_ctx_sp; 119 } 120 121 bool TargetThreadWindows::CalculateStopInfo() { 122 SetStopInfo(m_stop_info_sp); 123 return true; 124 } 125 126 Status TargetThreadWindows::DoResume() { 127 StateType resume_state = GetTemporaryResumeState(); 128 StateType current_state = GetState(); 129 if (resume_state == current_state) 130 return Status(); 131 132 if (resume_state == eStateStepping) { 133 uint32_t flags_index = 134 GetRegisterContext()->ConvertRegisterKindToRegisterNumber( 135 eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS); 136 uint64_t flags_value = 137 GetRegisterContext()->ReadRegisterAsUnsigned(flags_index, 0); 138 flags_value |= 0x100; // Set the trap flag on the CPU 139 GetRegisterContext()->WriteRegisterFromUnsigned(flags_index, flags_value); 140 } 141 142 if (resume_state == eStateStepping || resume_state == eStateRunning) { 143 DWORD previous_suspend_count = 0; 144 HANDLE thread_handle = m_host_thread.GetNativeThread().GetSystemHandle(); 145 do { 146 // ResumeThread returns -1 on error, or the thread's *previous* suspend 147 // count on success. This means that the return value is 1 when the thread 148 // was restarted. Note that DWORD is an unsigned int, so we need to 149 // explicitly compare with -1. 150 previous_suspend_count = ::ResumeThread(thread_handle); 151 152 if (previous_suspend_count == (DWORD)-1) 153 return Status(::GetLastError(), eErrorTypeWin32); 154 155 } while (previous_suspend_count > 1); 156 } 157 158 return Status(); 159 } 160