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