1//===-- SymbolFileCTF.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 "SymbolFileCTF.h" 10 11#include "lldb/Core/Module.h" 12#include "lldb/Core/PluginManager.h" 13#include "lldb/Host/Config.h" 14#include "lldb/Symbol/CompileUnit.h" 15#include "lldb/Symbol/Function.h" 16#include "lldb/Symbol/ObjectFile.h" 17#include "lldb/Symbol/Symbol.h" 18#include "lldb/Symbol/SymbolContext.h" 19#include "lldb/Symbol/Symtab.h" 20#include "lldb/Symbol/TypeList.h" 21#include "lldb/Symbol/TypeMap.h" 22#include "lldb/Symbol/Variable.h" 23#include "lldb/Symbol/VariableList.h" 24#include "lldb/Utility/DataExtractor.h" 25#include "lldb/Utility/LLDBLog.h" 26#include "lldb/Utility/Log.h" 27#include "lldb/Utility/RegularExpression.h" 28#include "lldb/Utility/StreamBuffer.h" 29#include "lldb/Utility/StreamString.h" 30#include "lldb/Utility/Timer.h" 31#include "llvm/Support/MemoryBuffer.h" 32 33#include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h" 34#include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 35 36#include <memory> 37#include <optional> 38 39#if LLVM_ENABLE_ZLIB 40#include <zlib.h> 41#endif 42 43using namespace llvm; 44using namespace lldb; 45using namespace lldb_private; 46 47LLDB_PLUGIN_DEFINE(SymbolFileCTF) 48 49char SymbolFileCTF::ID; 50 51SymbolFileCTF::SymbolFileCTF(lldb::ObjectFileSP objfile_sp) 52 : SymbolFileCommon(std::move(objfile_sp)) {} 53 54void SymbolFileCTF::Initialize() { 55 PluginManager::RegisterPlugin(GetPluginNameStatic(), 56 GetPluginDescriptionStatic(), CreateInstance); 57} 58 59void SymbolFileCTF::Terminate() { 60 PluginManager::UnregisterPlugin(CreateInstance); 61} 62 63llvm::StringRef SymbolFileCTF::GetPluginDescriptionStatic() { 64 return "Compact C Type Format Symbol Reader"; 65} 66 67SymbolFile *SymbolFileCTF::CreateInstance(ObjectFileSP objfile_sp) { 68 return new SymbolFileCTF(std::move(objfile_sp)); 69} 70 71bool SymbolFileCTF::ParseHeader() { 72 if (m_header) 73 return true; 74 75 Log *log = GetLog(LLDBLog::Symbols); 76 77 ModuleSP module_sp(m_objfile_sp->GetModule()); 78 const SectionList *section_list = module_sp->GetSectionList(); 79 if (!section_list) 80 return false; 81 82 SectionSP section_sp( 83 section_list->FindSectionByType(lldb::eSectionTypeCTF, true)); 84 if (!section_sp) 85 return false; 86 87 m_objfile_sp->ReadSectionData(section_sp.get(), m_data); 88 89 if (m_data.GetByteSize() == 0) 90 return false; 91 92 StreamString module_desc; 93 GetObjectFile()->GetModule()->GetDescription(module_desc.AsRawOstream(), 94 lldb::eDescriptionLevelBrief); 95 LLDB_LOG(log, "Parsing Compact C Type format for {0}", module_desc.GetData()); 96 97 lldb::offset_t offset = 0; 98 99 // Parse CTF header. 100 constexpr size_t ctf_header_size = sizeof(ctf_header_t); 101 if (!m_data.ValidOffsetForDataOfSize(offset, ctf_header_size)) { 102 LLDB_LOG(log, "CTF parsing failed: insufficient data for CTF header"); 103 return false; 104 } 105 106 m_header.emplace(); 107 108 ctf_header_t &ctf_header = *m_header; 109 ctf_header.preamble.magic = m_data.GetU16(&offset); 110 ctf_header.preamble.version = m_data.GetU8(&offset); 111 ctf_header.preamble.flags = m_data.GetU8(&offset); 112 ctf_header.parlabel = m_data.GetU32(&offset); 113 ctf_header.parname = m_data.GetU32(&offset); 114 ctf_header.lbloff = m_data.GetU32(&offset); 115 ctf_header.objtoff = m_data.GetU32(&offset); 116 ctf_header.funcoff = m_data.GetU32(&offset); 117 ctf_header.typeoff = m_data.GetU32(&offset); 118 ctf_header.stroff = m_data.GetU32(&offset); 119 ctf_header.strlen = m_data.GetU32(&offset); 120 121 // Validate the preamble. 122 if (ctf_header.preamble.magic != g_ctf_magic) { 123 LLDB_LOG(log, "CTF parsing failed: invalid magic: {0:x}", 124 ctf_header.preamble.magic); 125 return false; 126 } 127 128 if (ctf_header.preamble.version != g_ctf_version) { 129 LLDB_LOG(log, "CTF parsing failed: unsupported version: {0}", 130 ctf_header.preamble.version); 131 return false; 132 } 133 134 LLDB_LOG(log, "Parsed valid CTF preamble: version {0}, flags {1:x}", 135 ctf_header.preamble.version, ctf_header.preamble.flags); 136 137 m_body_offset = offset; 138 139 if (ctf_header.preamble.flags & eFlagCompress) { 140 // The body has been compressed with zlib deflate. Header offsets point into 141 // the decompressed data. 142#if LLVM_ENABLE_ZLIB 143 const std::size_t decompressed_size = ctf_header.stroff + ctf_header.strlen; 144 DataBufferSP decompressed_data = 145 std::make_shared<DataBufferHeap>(decompressed_size, 0x0); 146 147 z_stream zstr; 148 memset(&zstr, 0, sizeof(zstr)); 149 zstr.next_in = (Bytef *)const_cast<uint8_t *>(m_data.GetDataStart() + 150 sizeof(ctf_header_t)); 151 zstr.avail_in = m_data.BytesLeft(offset); 152 zstr.next_out = 153 (Bytef *)const_cast<uint8_t *>(decompressed_data->GetBytes()); 154 zstr.avail_out = decompressed_size; 155 156 int rc = inflateInit(&zstr); 157 if (rc != Z_OK) { 158 LLDB_LOG(log, "CTF parsing failed: inflate initialization error: {0}", 159 zError(rc)); 160 return false; 161 } 162 163 rc = inflate(&zstr, Z_FINISH); 164 if (rc != Z_STREAM_END) { 165 LLDB_LOG(log, "CTF parsing failed: inflate error: {0}", zError(rc)); 166 return false; 167 } 168 169 rc = inflateEnd(&zstr); 170 if (rc != Z_OK) { 171 LLDB_LOG(log, "CTF parsing failed: inflate end error: {0}", zError(rc)); 172 return false; 173 } 174 175 if (zstr.total_out != decompressed_size) { 176 LLDB_LOG(log, 177 "CTF parsing failed: decompressed size ({0}) doesn't match " 178 "expected size ([1})", 179 zstr.total_out, decompressed_size); 180 return false; 181 } 182 183 m_data = DataExtractor(decompressed_data, m_data.GetByteOrder(), 184 m_data.GetAddressByteSize()); 185 m_body_offset = 0; 186#else 187 LLDB_LOG( 188 log, 189 "CTF parsing failed: data is compressed but no zlib inflate support"); 190 return false; 191#endif 192 } 193 194 // Validate the header. 195 if (!m_data.ValidOffset(m_body_offset + ctf_header.lbloff)) { 196 LLDB_LOG(log, 197 "CTF parsing failed: invalid label section offset in header: {0}", 198 ctf_header.lbloff); 199 return false; 200 } 201 202 if (!m_data.ValidOffset(m_body_offset + ctf_header.objtoff)) { 203 LLDB_LOG(log, 204 "CTF parsing failed: invalid object section offset in header: {0}", 205 ctf_header.objtoff); 206 return false; 207 } 208 209 if (!m_data.ValidOffset(m_body_offset + ctf_header.funcoff)) { 210 LLDB_LOG( 211 log, 212 "CTF parsing failed: invalid function section offset in header: {0}", 213 ctf_header.funcoff); 214 return false; 215 } 216 217 if (!m_data.ValidOffset(m_body_offset + ctf_header.typeoff)) { 218 LLDB_LOG(log, 219 "CTF parsing failed: invalid type section offset in header: {0}", 220 ctf_header.typeoff); 221 return false; 222 } 223 224 if (!m_data.ValidOffset(m_body_offset + ctf_header.stroff)) { 225 LLDB_LOG(log, 226 "CTF parsing failed: invalid string section offset in header: {0}", 227 ctf_header.stroff); 228 return false; 229 } 230 231 const lldb::offset_t str_end_offset = 232 m_body_offset + ctf_header.stroff + ctf_header.strlen; 233 if (!m_data.ValidOffset(str_end_offset - 1)) { 234 LLDB_LOG(log, 235 "CTF parsing failed: invalid string section length in header: {0}", 236 ctf_header.strlen); 237 return false; 238 } 239 240 if (m_body_offset + ctf_header.stroff + ctf_header.parlabel > 241 str_end_offset) { 242 LLDB_LOG(log, 243 "CTF parsing failed: invalid parent label offset: {0} exceeds end " 244 "of string section ({1})", 245 ctf_header.parlabel, str_end_offset); 246 return false; 247 } 248 249 if (m_body_offset + ctf_header.stroff + ctf_header.parname > str_end_offset) { 250 LLDB_LOG(log, 251 "CTF parsing failed: invalid parent name offset: {0} exceeds end " 252 "of string section ({1})", 253 ctf_header.parname, str_end_offset); 254 return false; 255 } 256 257 LLDB_LOG(log, 258 "Parsed valid CTF header: lbloff = {0}, objtoff = {1}, funcoff = " 259 "{2}, typeoff = {3}, stroff = {4}, strlen = {5}", 260 ctf_header.lbloff, ctf_header.objtoff, ctf_header.funcoff, 261 ctf_header.typeoff, ctf_header.stroff, ctf_header.strlen); 262 263 return true; 264} 265 266void SymbolFileCTF::InitializeObject() { 267 Log *log = GetLog(LLDBLog::Symbols); 268 269 auto type_system_or_err = GetTypeSystemForLanguage(lldb::eLanguageTypeC); 270 if (auto err = type_system_or_err.takeError()) { 271 LLDB_LOG_ERROR(log, std::move(err), "Unable to get type system: {0}"); 272 return; 273 } 274 275 auto ts = *type_system_or_err; 276 m_ast = llvm::dyn_cast_or_null<TypeSystemClang>(ts.get()); 277 LazyBool optimized = eLazyBoolNo; 278 m_comp_unit_sp = std::make_shared<CompileUnit>( 279 m_objfile_sp->GetModule(), nullptr, "", 0, eLanguageTypeC, optimized); 280 281 ParseTypes(*m_comp_unit_sp); 282} 283 284llvm::StringRef SymbolFileCTF::ReadString(lldb::offset_t str_offset) const { 285 lldb::offset_t offset = m_body_offset + m_header->stroff + str_offset; 286 if (!m_data.ValidOffset(offset)) 287 return "(invalid)"; 288 const char *str = m_data.GetCStr(&offset); 289 if (str && !*str) 290 return "(anon)"; 291 return llvm::StringRef(str); 292} 293 294/// Return the integer display representation encoded in the given data. 295static uint32_t GetEncoding(uint32_t data) { 296 // Mask bits 24���31. 297 return ((data)&0xff000000) >> 24; 298} 299 300/// Return the integral width in bits encoded in the given data. 301static uint32_t GetBits(uint32_t data) { 302 // Mask bits 0-15. 303 return (data)&0x0000ffff; 304} 305 306/// Return the type kind encoded in the given data. 307uint32_t GetKind(uint32_t data) { 308 // Mask bits 26���31. 309 return ((data)&0xf800) >> 11; 310} 311 312/// Return the variable length encoded in the given data. 313uint32_t GetVLen(uint32_t data) { 314 // Mask bits 0���24. 315 return (data)&0x3ff; 316} 317 318static uint32_t GetBytes(uint32_t bits) { return bits / sizeof(unsigned); } 319 320static clang::TagTypeKind TranslateRecordKind(CTFType::Kind type) { 321 switch (type) { 322 case CTFType::Kind::eStruct: 323 return clang::TagTypeKind::Struct; 324 case CTFType::Kind::eUnion: 325 return clang::TagTypeKind::Union; 326 default: 327 lldbassert(false && "Invalid record kind!"); 328 return clang::TagTypeKind::Struct; 329 } 330} 331 332llvm::Expected<TypeSP> 333SymbolFileCTF::CreateInteger(const CTFInteger &ctf_integer) { 334 lldb::BasicType basic_type = 335 TypeSystemClang::GetBasicTypeEnumeration(ctf_integer.name); 336 if (basic_type == eBasicTypeInvalid) 337 return llvm::make_error<llvm::StringError>( 338 llvm::formatv("unsupported integer type: no corresponding basic clang " 339 "type for '{0}'", 340 ctf_integer.name), 341 llvm::inconvertibleErrorCode()); 342 343 CompilerType compiler_type = m_ast->GetBasicType(basic_type); 344 345 if (basic_type != eBasicTypeVoid) { 346 // Make sure the type we got is an integer type. 347 bool compiler_type_is_signed = false; 348 if (!compiler_type.IsIntegerType(compiler_type_is_signed)) 349 return llvm::make_error<llvm::StringError>( 350 llvm::formatv( 351 "Found compiler type for '{0}' but it's not an integer type: {1}", 352 ctf_integer.name, 353 compiler_type.GetDisplayTypeName().GetStringRef()), 354 llvm::inconvertibleErrorCode()); 355 356 // Make sure the signing matches between the CTF and the compiler type. 357 const bool type_is_signed = (ctf_integer.encoding & IntEncoding::eSigned); 358 if (compiler_type_is_signed != type_is_signed) 359 return llvm::make_error<llvm::StringError>( 360 llvm::formatv("Found integer compiler type for {0} but compiler type " 361 "is {1} and {0} is {2}", 362 ctf_integer.name, 363 compiler_type_is_signed ? "signed" : "unsigned", 364 type_is_signed ? "signed" : "unsigned"), 365 llvm::inconvertibleErrorCode()); 366 } 367 368 Declaration decl; 369 return MakeType(ctf_integer.uid, ConstString(ctf_integer.name), 370 GetBytes(ctf_integer.bits), nullptr, LLDB_INVALID_UID, 371 lldb_private::Type::eEncodingIsUID, decl, compiler_type, 372 lldb_private::Type::ResolveState::Full); 373} 374 375llvm::Expected<lldb::TypeSP> 376SymbolFileCTF::CreateModifier(const CTFModifier &ctf_modifier) { 377 Type *ref_type = ResolveTypeUID(ctf_modifier.type); 378 if (!ref_type) 379 return llvm::make_error<llvm::StringError>( 380 llvm::formatv("Could not find modified type: {0}", ctf_modifier.type), 381 llvm::inconvertibleErrorCode()); 382 383 CompilerType compiler_type; 384 385 switch (ctf_modifier.kind) { 386 case CTFType::ePointer: 387 compiler_type = ref_type->GetFullCompilerType().GetPointerType(); 388 break; 389 case CTFType::eConst: 390 compiler_type = ref_type->GetFullCompilerType().AddConstModifier(); 391 break; 392 case CTFType::eVolatile: 393 compiler_type = ref_type->GetFullCompilerType().AddVolatileModifier(); 394 break; 395 case CTFType::eRestrict: 396 compiler_type = ref_type->GetFullCompilerType().AddRestrictModifier(); 397 break; 398 default: 399 return llvm::make_error<llvm::StringError>( 400 llvm::formatv("ParseModifier called with unsupported kind: {0}", 401 ctf_modifier.kind), 402 llvm::inconvertibleErrorCode()); 403 } 404 405 Declaration decl; 406 return MakeType(ctf_modifier.uid, ConstString(), 0, nullptr, LLDB_INVALID_UID, 407 Type::eEncodingIsUID, decl, compiler_type, 408 lldb_private::Type::ResolveState::Full); 409} 410 411llvm::Expected<lldb::TypeSP> 412SymbolFileCTF::CreateTypedef(const CTFTypedef &ctf_typedef) { 413 Type *underlying_type = ResolveTypeUID(ctf_typedef.type); 414 if (!underlying_type) 415 return llvm::make_error<llvm::StringError>( 416 llvm::formatv("Could not find typedef underlying type: {0}", 417 ctf_typedef.type), 418 llvm::inconvertibleErrorCode()); 419 420 CompilerType target_ast_type = underlying_type->GetFullCompilerType(); 421 clang::DeclContext *decl_ctx = m_ast->GetTranslationUnitDecl(); 422 CompilerType ast_typedef = target_ast_type.CreateTypedef( 423 ctf_typedef.name.data(), m_ast->CreateDeclContext(decl_ctx), 0); 424 425 Declaration decl; 426 return MakeType(ctf_typedef.uid, ConstString(ctf_typedef.name), 0, nullptr, 427 LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, 428 ast_typedef, lldb_private::Type::ResolveState::Full); 429} 430 431llvm::Expected<lldb::TypeSP> 432SymbolFileCTF::CreateArray(const CTFArray &ctf_array) { 433 Type *element_type = ResolveTypeUID(ctf_array.type); 434 if (!element_type) 435 return llvm::make_error<llvm::StringError>( 436 llvm::formatv("Could not find array element type: {0}", ctf_array.type), 437 llvm::inconvertibleErrorCode()); 438 439 std::optional<uint64_t> element_size = element_type->GetByteSize(nullptr); 440 if (!element_size) 441 return llvm::make_error<llvm::StringError>( 442 llvm::formatv("could not get element size of type: {0}", 443 ctf_array.type), 444 llvm::inconvertibleErrorCode()); 445 446 uint64_t size = ctf_array.nelems * *element_size; 447 448 CompilerType compiler_type = m_ast->CreateArrayType( 449 element_type->GetFullCompilerType(), ctf_array.nelems, 450 /*is_gnu_vector*/ false); 451 452 Declaration decl; 453 return MakeType(ctf_array.uid, ConstString(), size, nullptr, LLDB_INVALID_UID, 454 Type::eEncodingIsUID, decl, compiler_type, 455 lldb_private::Type::ResolveState::Full); 456} 457 458llvm::Expected<lldb::TypeSP> 459SymbolFileCTF::CreateEnum(const CTFEnum &ctf_enum) { 460 Declaration decl; 461 CompilerType enum_type = m_ast->CreateEnumerationType( 462 ctf_enum.name, m_ast->GetTranslationUnitDecl(), OptionalClangModuleID(), 463 decl, m_ast->GetBasicType(eBasicTypeInt), 464 /*is_scoped=*/false); 465 466 for (const CTFEnum::Value &value : ctf_enum.values) { 467 Declaration value_decl; 468 m_ast->AddEnumerationValueToEnumerationType( 469 enum_type, value_decl, value.name.data(), value.value, ctf_enum.size); 470 } 471 TypeSystemClang::CompleteTagDeclarationDefinition(enum_type); 472 473 return MakeType(ctf_enum.uid, ConstString(), 0, nullptr, LLDB_INVALID_UID, 474 Type::eEncodingIsUID, decl, enum_type, 475 lldb_private::Type::ResolveState::Full); 476} 477 478llvm::Expected<lldb::TypeSP> 479SymbolFileCTF::CreateFunction(const CTFFunction &ctf_function) { 480 std::vector<CompilerType> arg_types; 481 for (uint32_t arg : ctf_function.args) { 482 if (Type *arg_type = ResolveTypeUID(arg)) 483 arg_types.push_back(arg_type->GetFullCompilerType()); 484 } 485 486 Type *ret_type = ResolveTypeUID(ctf_function.return_type); 487 if (!ret_type) 488 return llvm::make_error<llvm::StringError>( 489 llvm::formatv("Could not find function return type: {0}", 490 ctf_function.return_type), 491 llvm::inconvertibleErrorCode()); 492 493 CompilerType func_type = m_ast->CreateFunctionType( 494 ret_type->GetFullCompilerType(), arg_types.data(), arg_types.size(), 495 ctf_function.variadic, 0, clang::CallingConv::CC_C); 496 497 Declaration decl; 498 return MakeType(ctf_function.uid, ConstString(ctf_function.name), 0, nullptr, 499 LLDB_INVALID_UID, Type::eEncodingIsUID, decl, func_type, 500 lldb_private::Type::ResolveState::Full); 501} 502 503llvm::Expected<lldb::TypeSP> 504SymbolFileCTF::CreateRecord(const CTFRecord &ctf_record) { 505 const clang::TagTypeKind tag_kind = TranslateRecordKind(ctf_record.kind); 506 CompilerType record_type = m_ast->CreateRecordType( 507 nullptr, OptionalClangModuleID(), eAccessPublic, ctf_record.name.data(), 508 llvm::to_underlying(tag_kind), eLanguageTypeC); 509 m_compiler_types[record_type.GetOpaqueQualType()] = &ctf_record; 510 Declaration decl; 511 return MakeType(ctf_record.uid, ConstString(ctf_record.name), ctf_record.size, 512 nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, 513 decl, record_type, lldb_private::Type::ResolveState::Forward); 514} 515 516bool SymbolFileCTF::CompleteType(CompilerType &compiler_type) { 517 // Check if we have a CTF type for the given incomplete compiler type. 518 auto it = m_compiler_types.find(compiler_type.GetOpaqueQualType()); 519 if (it == m_compiler_types.end()) 520 return false; 521 522 const CTFType *ctf_type = it->second; 523 assert(ctf_type && "m_compiler_types should only contain valid CTF types"); 524 525 // We only support resolving record types. 526 assert(llvm::isa<CTFRecord>(ctf_type)); 527 528 // Cast to the appropriate CTF type. 529 const CTFRecord *ctf_record = static_cast<const CTFRecord *>(ctf_type); 530 531 // If any of the fields are incomplete, we cannot complete the type. 532 for (const CTFRecord::Field &field : ctf_record->fields) { 533 if (!ResolveTypeUID(field.type)) { 534 LLDB_LOG(GetLog(LLDBLog::Symbols), 535 "Cannot complete type {0} because field {1} is incomplete", 536 ctf_type->uid, field.type); 537 return false; 538 } 539 } 540 541 // Complete the record type. 542 m_ast->StartTagDeclarationDefinition(compiler_type); 543 for (const CTFRecord::Field &field : ctf_record->fields) { 544 Type *field_type = ResolveTypeUID(field.type); 545 assert(field_type && "field must be complete"); 546 const uint32_t field_size = field_type->GetByteSize(nullptr).value_or(0); 547 TypeSystemClang::AddFieldToRecordType(compiler_type, field.name, 548 field_type->GetFullCompilerType(), 549 eAccessPublic, field_size); 550 } 551 m_ast->CompleteTagDeclarationDefinition(compiler_type); 552 553 // Now that the compiler type is complete, we don't need to remember it 554 // anymore and can remove the CTF record type. 555 m_compiler_types.erase(compiler_type.GetOpaqueQualType()); 556 m_ctf_types.erase(ctf_type->uid); 557 558 return true; 559} 560 561llvm::Expected<lldb::TypeSP> 562SymbolFileCTF::CreateForward(const CTFForward &ctf_forward) { 563 CompilerType forward_compiler_type = m_ast->CreateRecordType( 564 nullptr, OptionalClangModuleID(), eAccessPublic, ctf_forward.name, 565 llvm::to_underlying(clang::TagTypeKind::Struct), eLanguageTypeC); 566 Declaration decl; 567 return MakeType(ctf_forward.uid, ConstString(ctf_forward.name), 0, nullptr, 568 LLDB_INVALID_UID, Type::eEncodingIsUID, decl, 569 forward_compiler_type, Type::ResolveState::Forward); 570} 571 572llvm::Expected<TypeSP> SymbolFileCTF::CreateType(CTFType *ctf_type) { 573 if (!ctf_type) 574 return llvm::make_error<llvm::StringError>( 575 "cannot create type for unparsed type", llvm::inconvertibleErrorCode()); 576 577 switch (ctf_type->kind) { 578 case CTFType::Kind::eInteger: 579 return CreateInteger(*static_cast<CTFInteger *>(ctf_type)); 580 case CTFType::Kind::eConst: 581 case CTFType::Kind::ePointer: 582 case CTFType::Kind::eRestrict: 583 case CTFType::Kind::eVolatile: 584 return CreateModifier(*static_cast<CTFModifier *>(ctf_type)); 585 case CTFType::Kind::eTypedef: 586 return CreateTypedef(*static_cast<CTFTypedef *>(ctf_type)); 587 case CTFType::Kind::eArray: 588 return CreateArray(*static_cast<CTFArray *>(ctf_type)); 589 case CTFType::Kind::eEnum: 590 return CreateEnum(*static_cast<CTFEnum *>(ctf_type)); 591 case CTFType::Kind::eFunction: 592 return CreateFunction(*static_cast<CTFFunction *>(ctf_type)); 593 case CTFType::Kind::eStruct: 594 case CTFType::Kind::eUnion: 595 return CreateRecord(*static_cast<CTFRecord *>(ctf_type)); 596 case CTFType::Kind::eForward: 597 return CreateForward(*static_cast<CTFForward *>(ctf_type)); 598 case CTFType::Kind::eUnknown: 599 case CTFType::Kind::eFloat: 600 case CTFType::Kind::eSlice: 601 return llvm::make_error<llvm::StringError>( 602 llvm::formatv("unsupported type (uid = {0}, name = {1}, kind = {2})", 603 ctf_type->uid, ctf_type->name, ctf_type->kind), 604 llvm::inconvertibleErrorCode()); 605 } 606 llvm_unreachable("Unexpected CTF type kind"); 607} 608 609llvm::Expected<std::unique_ptr<CTFType>> 610SymbolFileCTF::ParseType(lldb::offset_t &offset, lldb::user_id_t uid) { 611 ctf_stype_t ctf_stype; 612 ctf_stype.name = m_data.GetU32(&offset); 613 ctf_stype.info = m_data.GetU32(&offset); 614 ctf_stype.size = m_data.GetU32(&offset); 615 616 llvm::StringRef name = ReadString(ctf_stype.name); 617 const uint32_t kind = GetKind(ctf_stype.info); 618 const uint32_t variable_length = GetVLen(ctf_stype.info); 619 const uint32_t type = ctf_stype.GetType(); 620 const uint32_t size = ctf_stype.GetSize(); 621 622 switch (kind) { 623 case TypeKind::eInteger: { 624 const uint32_t vdata = m_data.GetU32(&offset); 625 const uint32_t bits = GetBits(vdata); 626 const uint32_t encoding = GetEncoding(vdata); 627 return std::make_unique<CTFInteger>(uid, name, bits, encoding); 628 } 629 case TypeKind::eConst: 630 return std::make_unique<CTFConst>(uid, type); 631 case TypeKind::ePointer: 632 return std::make_unique<CTFPointer>(uid, type); 633 case TypeKind::eRestrict: 634 return std::make_unique<CTFRestrict>(uid, type); 635 case TypeKind::eVolatile: 636 return std::make_unique<CTFVolatile>(uid, type); 637 case TypeKind::eTypedef: 638 return std::make_unique<CTFTypedef>(uid, name, type); 639 case TypeKind::eArray: { 640 const uint32_t type = m_data.GetU32(&offset); 641 const uint32_t index = m_data.GetU32(&offset); 642 const uint32_t nelems = m_data.GetU32(&offset); 643 return std::make_unique<CTFArray>(uid, name, type, index, nelems); 644 } 645 case TypeKind::eEnum: { 646 std::vector<CTFEnum::Value> values; 647 for (uint32_t i = 0; i < variable_length; ++i) { 648 const uint32_t value_name = m_data.GetU32(&offset); 649 const uint32_t value = m_data.GetU32(&offset); 650 values.emplace_back(ReadString(value_name), value); 651 } 652 return std::make_unique<CTFEnum>(uid, name, variable_length, size, values); 653 } 654 case TypeKind::eFunction: { 655 std::vector<uint32_t> args; 656 bool variadic = false; 657 for (uint32_t i = 0; i < variable_length; ++i) { 658 const uint32_t arg_uid = m_data.GetU32(&offset); 659 // If the last argument is 0, this is a variadic function. 660 if (arg_uid == 0) { 661 variadic = true; 662 break; 663 } 664 args.push_back(arg_uid); 665 } 666 // If the number of arguments is odd, a single uint32_t of padding is 667 // inserted to maintain alignment. 668 if (variable_length % 2 == 1) 669 m_data.GetU32(&offset); 670 return std::make_unique<CTFFunction>(uid, name, variable_length, type, args, 671 variadic); 672 } 673 case TypeKind::eStruct: 674 case TypeKind::eUnion: { 675 std::vector<CTFRecord::Field> fields; 676 for (uint32_t i = 0; i < variable_length; ++i) { 677 const uint32_t field_name = m_data.GetU32(&offset); 678 const uint32_t type = m_data.GetU32(&offset); 679 uint64_t field_offset = 0; 680 if (size < g_ctf_field_threshold) { 681 field_offset = m_data.GetU16(&offset); 682 m_data.GetU16(&offset); // Padding 683 } else { 684 const uint32_t offset_hi = m_data.GetU32(&offset); 685 const uint32_t offset_lo = m_data.GetU32(&offset); 686 field_offset = (((uint64_t)offset_hi) << 32) | ((uint64_t)offset_lo); 687 } 688 fields.emplace_back(ReadString(field_name), type, field_offset); 689 } 690 return std::make_unique<CTFRecord>(static_cast<CTFType::Kind>(kind), uid, 691 name, variable_length, size, fields); 692 } 693 case TypeKind::eForward: 694 return std::make_unique<CTFForward>(uid, name); 695 case TypeKind::eUnknown: 696 return std::make_unique<CTFType>(static_cast<CTFType::Kind>(kind), uid, 697 name); 698 case TypeKind::eFloat: 699 case TypeKind::eSlice: 700 offset += (variable_length * sizeof(uint32_t)); 701 break; 702 } 703 704 return llvm::make_error<llvm::StringError>( 705 llvm::formatv("unsupported type (name = {0}, kind = {1}, vlength = {2})", 706 name, kind, variable_length), 707 llvm::inconvertibleErrorCode()); 708} 709 710size_t SymbolFileCTF::ParseTypes(CompileUnit &cu) { 711 if (!ParseHeader()) 712 return 0; 713 714 if (!m_types.empty()) 715 return 0; 716 717 if (!m_ast) 718 return 0; 719 720 Log *log = GetLog(LLDBLog::Symbols); 721 LLDB_LOG(log, "Parsing CTF types"); 722 723 lldb::offset_t type_offset = m_body_offset + m_header->typeoff; 724 const lldb::offset_t type_offset_end = m_body_offset + m_header->stroff; 725 726 lldb::user_id_t type_uid = 1; 727 while (type_offset < type_offset_end) { 728 llvm::Expected<std::unique_ptr<CTFType>> type_or_error = 729 ParseType(type_offset, type_uid); 730 if (type_or_error) { 731 m_ctf_types[(*type_or_error)->uid] = std::move(*type_or_error); 732 } else { 733 LLDB_LOG_ERROR(log, type_or_error.takeError(), 734 "Failed to parse type {1} at offset {2}: {0}", type_uid, 735 type_offset); 736 } 737 type_uid++; 738 } 739 740 LLDB_LOG(log, "Parsed {0} CTF types", m_ctf_types.size()); 741 742 for (lldb::user_id_t uid = 1; uid < type_uid; ++uid) 743 ResolveTypeUID(uid); 744 745 LLDB_LOG(log, "Created {0} CTF types", m_types.size()); 746 747 return m_types.size(); 748} 749 750size_t SymbolFileCTF::ParseFunctions(CompileUnit &cu) { 751 if (!ParseHeader()) 752 return 0; 753 754 if (!m_functions.empty()) 755 return 0; 756 757 if (!m_ast) 758 return 0; 759 760 Symtab *symtab = GetObjectFile()->GetModule()->GetSymtab(); 761 if (!symtab) 762 return 0; 763 764 Log *log = GetLog(LLDBLog::Symbols); 765 LLDB_LOG(log, "Parsing CTF functions"); 766 767 lldb::offset_t function_offset = m_body_offset + m_header->funcoff; 768 const lldb::offset_t function_offset_end = m_body_offset + m_header->typeoff; 769 770 uint32_t symbol_idx = 0; 771 Declaration decl; 772 while (function_offset < function_offset_end) { 773 const uint32_t info = m_data.GetU32(&function_offset); 774 const uint16_t kind = GetKind(info); 775 const uint16_t variable_length = GetVLen(info); 776 777 Symbol *symbol = symtab->FindSymbolWithType( 778 eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny, symbol_idx); 779 780 // Skip padding. 781 if (kind == TypeKind::eUnknown && variable_length == 0) 782 continue; 783 784 // Skip unexpected kinds. 785 if (kind != TypeKind::eFunction) 786 continue; 787 788 const uint32_t ret_uid = m_data.GetU32(&function_offset); 789 const uint32_t num_args = variable_length; 790 791 std::vector<CompilerType> arg_types; 792 arg_types.reserve(num_args); 793 794 bool is_variadic = false; 795 for (uint32_t i = 0; i < variable_length; i++) { 796 const uint32_t arg_uid = m_data.GetU32(&function_offset); 797 798 // If the last argument is 0, this is a variadic function. 799 if (arg_uid == 0) { 800 is_variadic = true; 801 break; 802 } 803 804 Type *arg_type = ResolveTypeUID(arg_uid); 805 arg_types.push_back(arg_type->GetFullCompilerType()); 806 } 807 808 if (symbol) { 809 Type *ret_type = ResolveTypeUID(ret_uid); 810 AddressRange func_range = 811 AddressRange(symbol->GetFileAddress(), symbol->GetByteSize(), 812 GetObjectFile()->GetModule()->GetSectionList()); 813 814 // Create function type. 815 CompilerType func_type = m_ast->CreateFunctionType( 816 ret_type->GetFullCompilerType(), arg_types.data(), arg_types.size(), 817 is_variadic, 0, clang::CallingConv::CC_C); 818 lldb::user_id_t function_type_uid = m_types.size() + 1; 819 TypeSP type_sp = 820 MakeType(function_type_uid, symbol->GetName(), 0, nullptr, 821 LLDB_INVALID_UID, Type::eEncodingIsUID, decl, func_type, 822 lldb_private::Type::ResolveState::Full); 823 m_types[function_type_uid] = type_sp; 824 825 // Create function. 826 lldb::user_id_t func_uid = m_functions.size(); 827 FunctionSP function_sp = std::make_shared<Function>( 828 &cu, func_uid, function_type_uid, symbol->GetMangled(), type_sp.get(), 829 func_range); 830 m_functions.emplace_back(function_sp); 831 cu.AddFunction(function_sp); 832 } 833 } 834 835 LLDB_LOG(log, "CTF parsed {0} functions", m_functions.size()); 836 837 return m_functions.size(); 838} 839 840static DWARFExpression CreateDWARFExpression(ModuleSP module_sp, 841 const Symbol &symbol) { 842 if (!module_sp) 843 return DWARFExpression(); 844 845 const ArchSpec &architecture = module_sp->GetArchitecture(); 846 ByteOrder byte_order = architecture.GetByteOrder(); 847 uint32_t address_size = architecture.GetAddressByteSize(); 848 uint32_t byte_size = architecture.GetDataByteSize(); 849 850 StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order); 851 stream.PutHex8(lldb_private::dwarf::DW_OP_addr); 852 stream.PutMaxHex64(symbol.GetFileAddress(), address_size, byte_order); 853 854 DataBufferSP buffer = 855 std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize()); 856 lldb_private::DataExtractor extractor(buffer, byte_order, address_size, 857 byte_size); 858 DWARFExpression result(extractor); 859 result.SetRegisterKind(eRegisterKindDWARF); 860 861 return result; 862} 863 864size_t SymbolFileCTF::ParseObjects(CompileUnit &comp_unit) { 865 if (!ParseHeader()) 866 return 0; 867 868 if (!m_variables.empty()) 869 return 0; 870 871 if (!m_ast) 872 return 0; 873 874 ModuleSP module_sp = GetObjectFile()->GetModule(); 875 Symtab *symtab = module_sp->GetSymtab(); 876 if (!symtab) 877 return 0; 878 879 Log *log = GetLog(LLDBLog::Symbols); 880 LLDB_LOG(log, "Parsing CTF objects"); 881 882 lldb::offset_t object_offset = m_body_offset + m_header->objtoff; 883 const lldb::offset_t object_offset_end = m_body_offset + m_header->funcoff; 884 885 uint32_t symbol_idx = 0; 886 Declaration decl; 887 while (object_offset < object_offset_end) { 888 const uint32_t type_uid = m_data.GetU32(&object_offset); 889 890 if (Symbol *symbol = 891 symtab->FindSymbolWithType(eSymbolTypeData, Symtab::eDebugYes, 892 Symtab::eVisibilityAny, symbol_idx)) { 893 Variable::RangeList ranges; 894 ranges.Append(symbol->GetFileAddress(), symbol->GetByteSize()); 895 896 auto type_sp = std::make_shared<SymbolFileType>(*this, type_uid); 897 898 DWARFExpressionList location( 899 module_sp, CreateDWARFExpression(module_sp, *symbol), nullptr); 900 901 lldb::user_id_t variable_type_uid = m_variables.size(); 902 m_variables.emplace_back(std::make_shared<Variable>( 903 variable_type_uid, symbol->GetName().AsCString(), 904 symbol->GetName().AsCString(), type_sp, eValueTypeVariableGlobal, 905 m_comp_unit_sp.get(), ranges, &decl, location, symbol->IsExternal(), 906 /*artificial=*/false, 907 /*location_is_constant_data*/ false)); 908 } 909 } 910 911 LLDB_LOG(log, "Parsed {0} CTF objects", m_variables.size()); 912 913 return m_variables.size(); 914} 915 916uint32_t SymbolFileCTF::CalculateAbilities() { 917 if (!m_objfile_sp) 918 return 0; 919 920 if (!ParseHeader()) 921 return 0; 922 923 return VariableTypes | Functions | GlobalVariables; 924} 925 926uint32_t SymbolFileCTF::ResolveSymbolContext(const Address &so_addr, 927 SymbolContextItem resolve_scope, 928 SymbolContext &sc) { 929 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); 930 if (m_objfile_sp->GetSymtab() == nullptr) 931 return 0; 932 933 uint32_t resolved_flags = 0; 934 935 // Resolve symbols. 936 if (resolve_scope & eSymbolContextSymbol) { 937 sc.symbol = m_objfile_sp->GetSymtab()->FindSymbolContainingFileAddress( 938 so_addr.GetFileAddress()); 939 if (sc.symbol) 940 resolved_flags |= eSymbolContextSymbol; 941 } 942 943 // Resolve functions. 944 if (resolve_scope & eSymbolContextFunction) { 945 for (FunctionSP function_sp : m_functions) { 946 if (function_sp->GetAddressRange().ContainsFileAddress( 947 so_addr.GetFileAddress())) { 948 sc.function = function_sp.get(); 949 resolved_flags |= eSymbolContextFunction; 950 break; 951 } 952 } 953 } 954 955 // Resolve variables. 956 if (resolve_scope & eSymbolContextVariable) { 957 for (VariableSP variable_sp : m_variables) { 958 if (variable_sp->LocationIsValidForAddress(so_addr.GetFileAddress())) { 959 sc.variable = variable_sp.get(); 960 break; 961 } 962 } 963 } 964 965 return resolved_flags; 966} 967 968CompUnitSP SymbolFileCTF::ParseCompileUnitAtIndex(uint32_t idx) { 969 if (idx == 0) 970 return m_comp_unit_sp; 971 return {}; 972} 973 974size_t 975SymbolFileCTF::ParseVariablesForContext(const lldb_private::SymbolContext &sc) { 976 return ParseObjects(*m_comp_unit_sp); 977} 978 979void SymbolFileCTF::AddSymbols(Symtab &symtab) { 980 // CTF does not encode symbols. 981 // We rely on the existing symbol table to map symbols to type. 982} 983 984lldb_private::Type *SymbolFileCTF::ResolveTypeUID(lldb::user_id_t type_uid) { 985 auto type_it = m_types.find(type_uid); 986 if (type_it != m_types.end()) 987 return type_it->second.get(); 988 989 auto ctf_type_it = m_ctf_types.find(type_uid); 990 if (ctf_type_it == m_ctf_types.end()) 991 return nullptr; 992 993 CTFType *ctf_type = ctf_type_it->second.get(); 994 assert(ctf_type && "m_ctf_types should only contain valid CTF types"); 995 996 Log *log = GetLog(LLDBLog::Symbols); 997 998 llvm::Expected<TypeSP> type_or_error = CreateType(ctf_type); 999 if (!type_or_error) { 1000 LLDB_LOG_ERROR(log, type_or_error.takeError(), 1001 "Failed to create type for {1}: {0}", ctf_type->uid); 1002 return {}; 1003 } 1004 1005 TypeSP type_sp = *type_or_error; 1006 1007 if (log) { 1008 StreamString ss; 1009 type_sp->Dump(&ss, true); 1010 LLDB_LOGV(log, "Adding type {0}: {1}", type_sp->GetID(), 1011 llvm::StringRef(ss.GetString()).rtrim()); 1012 } 1013 1014 m_types[type_uid] = type_sp; 1015 1016 // Except for record types which we'll need to complete later, we don't need 1017 // the CTF type anymore. 1018 if (!isa<CTFRecord>(ctf_type)) 1019 m_ctf_types.erase(type_uid); 1020 1021 return type_sp.get(); 1022} 1023 1024void SymbolFileCTF::FindTypes(const lldb_private::TypeQuery &match, 1025 lldb_private::TypeResults &results) { 1026 // Make sure we haven't already searched this SymbolFile before. 1027 if (results.AlreadySearched(this)) 1028 return; 1029 1030 ConstString name = match.GetTypeBasename(); 1031 for (TypeSP type_sp : GetTypeList().Types()) { 1032 if (type_sp && type_sp->GetName() == name) { 1033 results.InsertUnique(type_sp); 1034 if (results.Done(match)) 1035 return; 1036 } 1037 } 1038} 1039 1040void SymbolFileCTF::FindTypesByRegex( 1041 const lldb_private::RegularExpression ®ex, uint32_t max_matches, 1042 lldb_private::TypeMap &types) { 1043 ParseTypes(*m_comp_unit_sp); 1044 1045 size_t matches = 0; 1046 for (TypeSP type_sp : GetTypeList().Types()) { 1047 if (matches == max_matches) 1048 break; 1049 if (type_sp && regex.Execute(type_sp->GetName())) 1050 types.Insert(type_sp); 1051 matches++; 1052 } 1053} 1054 1055void SymbolFileCTF::FindFunctions( 1056 const lldb_private::Module::LookupInfo &lookup_info, 1057 const lldb_private::CompilerDeclContext &parent_decl_ctx, 1058 bool include_inlines, lldb_private::SymbolContextList &sc_list) { 1059 ParseFunctions(*m_comp_unit_sp); 1060 1061 ConstString name = lookup_info.GetLookupName(); 1062 for (FunctionSP function_sp : m_functions) { 1063 if (function_sp && function_sp->GetName() == name) { 1064 lldb_private::SymbolContext sc; 1065 sc.comp_unit = m_comp_unit_sp.get(); 1066 sc.function = function_sp.get(); 1067 sc_list.Append(sc); 1068 } 1069 } 1070} 1071 1072void SymbolFileCTF::FindFunctions(const lldb_private::RegularExpression ®ex, 1073 bool include_inlines, 1074 lldb_private::SymbolContextList &sc_list) { 1075 for (FunctionSP function_sp : m_functions) { 1076 if (function_sp && regex.Execute(function_sp->GetName())) { 1077 lldb_private::SymbolContext sc; 1078 sc.comp_unit = m_comp_unit_sp.get(); 1079 sc.function = function_sp.get(); 1080 sc_list.Append(sc); 1081 } 1082 } 1083} 1084 1085void SymbolFileCTF::FindGlobalVariables( 1086 lldb_private::ConstString name, 1087 const lldb_private::CompilerDeclContext &parent_decl_ctx, 1088 uint32_t max_matches, lldb_private::VariableList &variables) { 1089 ParseObjects(*m_comp_unit_sp); 1090 1091 size_t matches = 0; 1092 for (VariableSP variable_sp : m_variables) { 1093 if (matches == max_matches) 1094 break; 1095 if (variable_sp && variable_sp->GetName() == name) { 1096 variables.AddVariable(variable_sp); 1097 matches++; 1098 } 1099 } 1100} 1101 1102void SymbolFileCTF::FindGlobalVariables( 1103 const lldb_private::RegularExpression ®ex, uint32_t max_matches, 1104 lldb_private::VariableList &variables) { 1105 ParseObjects(*m_comp_unit_sp); 1106 1107 size_t matches = 0; 1108 for (VariableSP variable_sp : m_variables) { 1109 if (matches == max_matches) 1110 break; 1111 if (variable_sp && regex.Execute(variable_sp->GetName())) { 1112 variables.AddVariable(variable_sp); 1113 matches++; 1114 } 1115 } 1116} 1117