1 //===-- ThreadElfCore.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/Target/RegisterContext.h" 10 #include "lldb/Target/StopInfo.h" 11 #include "lldb/Target/Target.h" 12 #include "lldb/Target/Unwind.h" 13 #include "lldb/Utility/DataExtractor.h" 14 #include "lldb/Utility/Log.h" 15 16 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h" 17 #include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h" 18 #include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h" 19 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h" 20 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h" 21 #ifdef LLDB_ENABLE_ALL 22 #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h" 23 #endif // LLDB_ENABLE_ALL 24 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h" 25 #include "Plugins/Process/Utility/RegisterContextNetBSD_i386.h" 26 #include "Plugins/Process/Utility/RegisterContextNetBSD_x86_64.h" 27 #include "Plugins/Process/Utility/RegisterContextOpenBSD_i386.h" 28 #include "Plugins/Process/Utility/RegisterContextOpenBSD_x86_64.h" 29 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h" 30 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h" 31 #include "Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.h" 32 #include "ProcessElfCore.h" 33 #include "RegisterContextPOSIXCore_arm.h" 34 #include "RegisterContextPOSIXCore_arm64.h" 35 #include "RegisterContextPOSIXCore_mips64.h" 36 #include "RegisterContextPOSIXCore_powerpc.h" 37 #include "RegisterContextPOSIXCore_ppc64le.h" 38 #ifdef LLDB_ENABLE_ALL 39 #include "RegisterContextPOSIXCore_s390x.h" 40 #endif // LLDB_ENABLE_ALL 41 #include "RegisterContextPOSIXCore_x86_64.h" 42 #include "ThreadElfCore.h" 43 44 #include <memory> 45 46 using namespace lldb; 47 using namespace lldb_private; 48 49 // Construct a Thread object with given data 50 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td) 51 : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(), 52 m_signo(td.signo), m_gpregset_data(td.gpregset), m_notes(td.notes) {} 53 54 ThreadElfCore::~ThreadElfCore() { DestroyThread(); } 55 56 void ThreadElfCore::RefreshStateAfterStop() { 57 GetRegisterContext()->InvalidateIfNeeded(false); 58 } 59 60 RegisterContextSP ThreadElfCore::GetRegisterContext() { 61 if (!m_reg_context_sp) { 62 m_reg_context_sp = CreateRegisterContextForFrame(nullptr); 63 } 64 return m_reg_context_sp; 65 } 66 67 RegisterContextSP 68 ThreadElfCore::CreateRegisterContextForFrame(StackFrame *frame) { 69 RegisterContextSP reg_ctx_sp; 70 uint32_t concrete_frame_idx = 0; 71 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD)); 72 73 if (frame) 74 concrete_frame_idx = frame->GetConcreteFrameIndex(); 75 76 if (concrete_frame_idx == 0) { 77 if (m_thread_reg_ctx_sp) 78 return m_thread_reg_ctx_sp; 79 80 ProcessElfCore *process = static_cast<ProcessElfCore *>(GetProcess().get()); 81 ArchSpec arch = process->GetArchitecture(); 82 RegisterInfoInterface *reg_interface = nullptr; 83 84 switch (arch.GetTriple().getOS()) { 85 case llvm::Triple::FreeBSD: { 86 switch (arch.GetMachine()) { 87 case llvm::Triple::aarch64: 88 case llvm::Triple::arm: 89 break; 90 case llvm::Triple::ppc: 91 reg_interface = new RegisterContextFreeBSD_powerpc32(arch); 92 break; 93 case llvm::Triple::ppc64: 94 reg_interface = new RegisterContextFreeBSD_powerpc64(arch); 95 break; 96 case llvm::Triple::mips64: 97 reg_interface = new RegisterContextFreeBSD_mips64(arch); 98 break; 99 case llvm::Triple::x86: 100 reg_interface = new RegisterContextFreeBSD_i386(arch); 101 break; 102 case llvm::Triple::x86_64: 103 reg_interface = new RegisterContextFreeBSD_x86_64(arch); 104 break; 105 default: 106 break; 107 } 108 break; 109 } 110 111 case llvm::Triple::NetBSD: { 112 switch (arch.GetMachine()) { 113 case llvm::Triple::aarch64: 114 break; 115 case llvm::Triple::x86: 116 reg_interface = new RegisterContextNetBSD_i386(arch); 117 break; 118 case llvm::Triple::x86_64: 119 reg_interface = new RegisterContextNetBSD_x86_64(arch); 120 break; 121 default: 122 break; 123 } 124 break; 125 } 126 127 case llvm::Triple::Linux: { 128 switch (arch.GetMachine()) { 129 case llvm::Triple::aarch64: 130 break; 131 case llvm::Triple::ppc64le: 132 reg_interface = new RegisterInfoPOSIX_ppc64le(arch); 133 break; 134 #ifdef LLDB_ENABLE_ALL 135 case llvm::Triple::systemz: 136 reg_interface = new RegisterContextLinux_s390x(arch); 137 break; 138 #endif // LLDB_ENABLE_ALL 139 case llvm::Triple::x86: 140 reg_interface = new RegisterContextLinux_i386(arch); 141 break; 142 case llvm::Triple::x86_64: 143 reg_interface = new RegisterContextLinux_x86_64(arch); 144 break; 145 default: 146 break; 147 } 148 break; 149 } 150 151 case llvm::Triple::OpenBSD: { 152 switch (arch.GetMachine()) { 153 case llvm::Triple::aarch64: 154 break; 155 case llvm::Triple::x86: 156 reg_interface = new RegisterContextOpenBSD_i386(arch); 157 break; 158 case llvm::Triple::x86_64: 159 reg_interface = new RegisterContextOpenBSD_x86_64(arch); 160 break; 161 default: 162 break; 163 } 164 break; 165 } 166 167 default: 168 break; 169 } 170 171 if (!reg_interface && arch.GetMachine() != llvm::Triple::aarch64 && 172 arch.GetMachine() != llvm::Triple::arm) { 173 LLDB_LOGF(log, "elf-core::%s:: Architecture(%d) or OS(%d) not supported", 174 __FUNCTION__, arch.GetMachine(), arch.GetTriple().getOS()); 175 assert(false && "Architecture or OS not supported"); 176 } 177 178 switch (arch.GetMachine()) { 179 case llvm::Triple::aarch64: 180 m_thread_reg_ctx_sp = RegisterContextCorePOSIX_arm64::Create( 181 *this, arch, m_gpregset_data, m_notes); 182 break; 183 case llvm::Triple::arm: 184 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_arm>( 185 *this, std::make_unique<RegisterInfoPOSIX_arm>(arch), m_gpregset_data, 186 m_notes); 187 break; 188 case llvm::Triple::mipsel: 189 case llvm::Triple::mips: 190 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_mips64>( 191 *this, reg_interface, m_gpregset_data, m_notes); 192 break; 193 case llvm::Triple::mips64: 194 case llvm::Triple::mips64el: 195 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_mips64>( 196 *this, reg_interface, m_gpregset_data, m_notes); 197 break; 198 case llvm::Triple::ppc: 199 case llvm::Triple::ppc64: 200 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_powerpc>( 201 *this, reg_interface, m_gpregset_data, m_notes); 202 break; 203 case llvm::Triple::ppc64le: 204 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_ppc64le>( 205 *this, reg_interface, m_gpregset_data, m_notes); 206 break; 207 #ifdef LLDB_ENABLE_ALL 208 case llvm::Triple::systemz: 209 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_s390x>( 210 *this, reg_interface, m_gpregset_data, m_notes); 211 break; 212 #endif // LLDB_ENABLE_ALL 213 case llvm::Triple::x86: 214 case llvm::Triple::x86_64: 215 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_x86_64>( 216 *this, reg_interface, m_gpregset_data, m_notes); 217 break; 218 default: 219 break; 220 } 221 222 reg_ctx_sp = m_thread_reg_ctx_sp; 223 } else { 224 reg_ctx_sp = GetUnwinder().CreateRegisterContextForFrame(frame); 225 } 226 return reg_ctx_sp; 227 } 228 229 bool ThreadElfCore::CalculateStopInfo() { 230 ProcessSP process_sp(GetProcess()); 231 if (process_sp) { 232 SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, m_signo)); 233 return true; 234 } 235 return false; 236 } 237 238 // Parse PRSTATUS from NOTE entry 239 ELFLinuxPrStatus::ELFLinuxPrStatus() { 240 memset(this, 0, sizeof(ELFLinuxPrStatus)); 241 } 242 243 size_t ELFLinuxPrStatus::GetSize(const lldb_private::ArchSpec &arch) { 244 constexpr size_t mips_linux_pr_status_size_o32 = 96; 245 constexpr size_t mips_linux_pr_status_size_n32 = 72; 246 constexpr size_t num_ptr_size_members = 10; 247 if (arch.IsMIPS()) { 248 std::string abi = arch.GetTargetABI(); 249 assert(!abi.empty() && "ABI is not set"); 250 if (!abi.compare("n64")) 251 return sizeof(ELFLinuxPrStatus); 252 else if (!abi.compare("o32")) 253 return mips_linux_pr_status_size_o32; 254 // N32 ABI 255 return mips_linux_pr_status_size_n32; 256 } 257 switch (arch.GetCore()) { 258 case lldb_private::ArchSpec::eCore_x86_32_i386: 259 case lldb_private::ArchSpec::eCore_x86_32_i486: 260 return 72; 261 default: 262 if (arch.GetAddressByteSize() == 8) 263 return sizeof(ELFLinuxPrStatus); 264 else 265 return sizeof(ELFLinuxPrStatus) - num_ptr_size_members * 4; 266 } 267 } 268 269 Status ELFLinuxPrStatus::Parse(const DataExtractor &data, 270 const ArchSpec &arch) { 271 Status error; 272 if (GetSize(arch) > data.GetByteSize()) { 273 error.SetErrorStringWithFormat( 274 "NT_PRSTATUS size should be %zu, but the remaining bytes are: %" PRIu64, 275 GetSize(arch), data.GetByteSize()); 276 return error; 277 } 278 279 // Read field by field to correctly account for endianess of both the core 280 // dump and the platform running lldb. 281 offset_t offset = 0; 282 si_signo = data.GetU32(&offset); 283 si_code = data.GetU32(&offset); 284 si_errno = data.GetU32(&offset); 285 286 pr_cursig = data.GetU16(&offset); 287 offset += 2; // pad 288 289 pr_sigpend = data.GetAddress(&offset); 290 pr_sighold = data.GetAddress(&offset); 291 292 pr_pid = data.GetU32(&offset); 293 pr_ppid = data.GetU32(&offset); 294 pr_pgrp = data.GetU32(&offset); 295 pr_sid = data.GetU32(&offset); 296 297 pr_utime.tv_sec = data.GetAddress(&offset); 298 pr_utime.tv_usec = data.GetAddress(&offset); 299 300 pr_stime.tv_sec = data.GetAddress(&offset); 301 pr_stime.tv_usec = data.GetAddress(&offset); 302 303 pr_cutime.tv_sec = data.GetAddress(&offset); 304 pr_cutime.tv_usec = data.GetAddress(&offset); 305 306 pr_cstime.tv_sec = data.GetAddress(&offset); 307 pr_cstime.tv_usec = data.GetAddress(&offset); 308 309 return error; 310 } 311 312 // Parse PRPSINFO from NOTE entry 313 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() { 314 memset(this, 0, sizeof(ELFLinuxPrPsInfo)); 315 } 316 317 size_t ELFLinuxPrPsInfo::GetSize(const lldb_private::ArchSpec &arch) { 318 constexpr size_t mips_linux_pr_psinfo_size_o32_n32 = 128; 319 if (arch.IsMIPS()) { 320 uint8_t address_byte_size = arch.GetAddressByteSize(); 321 if (address_byte_size == 8) 322 return sizeof(ELFLinuxPrPsInfo); 323 return mips_linux_pr_psinfo_size_o32_n32; 324 } 325 326 switch (arch.GetCore()) { 327 case lldb_private::ArchSpec::eCore_s390x_generic: 328 case lldb_private::ArchSpec::eCore_x86_64_x86_64: 329 return sizeof(ELFLinuxPrPsInfo); 330 case lldb_private::ArchSpec::eCore_x86_32_i386: 331 case lldb_private::ArchSpec::eCore_x86_32_i486: 332 return 124; 333 default: 334 return 0; 335 } 336 } 337 338 Status ELFLinuxPrPsInfo::Parse(const DataExtractor &data, 339 const ArchSpec &arch) { 340 Status error; 341 ByteOrder byteorder = data.GetByteOrder(); 342 if (GetSize(arch) > data.GetByteSize()) { 343 error.SetErrorStringWithFormat( 344 "NT_PRPSINFO size should be %zu, but the remaining bytes are: %" PRIu64, 345 GetSize(arch), data.GetByteSize()); 346 return error; 347 } 348 size_t size = 0; 349 offset_t offset = 0; 350 351 pr_state = data.GetU8(&offset); 352 pr_sname = data.GetU8(&offset); 353 pr_zomb = data.GetU8(&offset); 354 pr_nice = data.GetU8(&offset); 355 if (data.GetAddressByteSize() == 8) { 356 // Word align the next field on 64 bit. 357 offset += 4; 358 } 359 360 pr_flag = data.GetAddress(&offset); 361 362 if (arch.IsMIPS()) { 363 // The pr_uid and pr_gid is always 32 bit irrespective of platforms 364 pr_uid = data.GetU32(&offset); 365 pr_gid = data.GetU32(&offset); 366 } else { 367 // 16 bit on 32 bit platforms, 32 bit on 64 bit platforms 368 pr_uid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1); 369 pr_gid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1); 370 } 371 372 pr_pid = data.GetU32(&offset); 373 pr_ppid = data.GetU32(&offset); 374 pr_pgrp = data.GetU32(&offset); 375 pr_sid = data.GetU32(&offset); 376 377 size = 16; 378 data.ExtractBytes(offset, size, byteorder, pr_fname); 379 offset += size; 380 381 size = 80; 382 data.ExtractBytes(offset, size, byteorder, pr_psargs); 383 offset += size; 384 385 return error; 386 } 387 388 // Parse SIGINFO from NOTE entry 389 ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); } 390 391 size_t ELFLinuxSigInfo::GetSize(const lldb_private::ArchSpec &arch) { 392 if (arch.IsMIPS()) 393 return sizeof(ELFLinuxSigInfo); 394 switch (arch.GetCore()) { 395 case lldb_private::ArchSpec::eCore_x86_64_x86_64: 396 return sizeof(ELFLinuxSigInfo); 397 case lldb_private::ArchSpec::eCore_s390x_generic: 398 case lldb_private::ArchSpec::eCore_x86_32_i386: 399 case lldb_private::ArchSpec::eCore_x86_32_i486: 400 return 12; 401 default: 402 return 0; 403 } 404 } 405 406 Status ELFLinuxSigInfo::Parse(const DataExtractor &data, const ArchSpec &arch) { 407 Status error; 408 if (GetSize(arch) > data.GetByteSize()) { 409 error.SetErrorStringWithFormat( 410 "NT_SIGINFO size should be %zu, but the remaining bytes are: %" PRIu64, 411 GetSize(arch), data.GetByteSize()); 412 return error; 413 } 414 415 // Parsing from a 32 bit ELF core file, and populating/reusing the structure 416 // properly, because the struct is for the 64 bit version 417 offset_t offset = 0; 418 si_signo = data.GetU32(&offset); 419 si_code = data.GetU32(&offset); 420 si_errno = data.GetU32(&offset); 421 422 return error; 423 } 424