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