1 #include "UdtRecordCompleter.h" 2 3 #include "PdbAstBuilder.h" 4 #include "PdbIndex.h" 5 #include "PdbSymUid.h" 6 #include "PdbUtil.h" 7 8 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h" 9 #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h" 10 #include "Plugins/ExpressionParser/Clang/ClangUtil.h" 11 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 12 #include "SymbolFileNativePDB.h" 13 #include "lldb/Core/Address.h" 14 #include "lldb/Symbol/Type.h" 15 #include "lldb/Utility/LLDBAssert.h" 16 #include "lldb/Utility/LLDBLog.h" 17 #include "lldb/lldb-enumerations.h" 18 #include "lldb/lldb-forward.h" 19 20 #include "llvm/ADT/STLExtras.h" 21 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h" 22 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h" 23 #include "llvm/DebugInfo/CodeView/TypeIndex.h" 24 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h" 25 #include "llvm/DebugInfo/PDB/Native/TpiStream.h" 26 #include "llvm/DebugInfo/PDB/PDBTypes.h" 27 #include <optional> 28 29 using namespace llvm::codeview; 30 using namespace llvm::pdb; 31 using namespace lldb; 32 using namespace lldb_private; 33 using namespace lldb_private::npdb; 34 35 using Error = llvm::Error; 36 37 UdtRecordCompleter::UdtRecordCompleter( 38 PdbTypeSymId id, CompilerType &derived_ct, clang::TagDecl &tag_decl, 39 PdbAstBuilder &ast_builder, PdbIndex &index, 40 llvm::DenseMap<clang::Decl *, DeclStatus> &decl_to_status, 41 llvm::DenseMap<lldb::opaque_compiler_type_t, 42 llvm::SmallSet<std::pair<llvm::StringRef, CompilerType>, 8>> 43 &cxx_record_map) 44 : m_id(id), m_derived_ct(derived_ct), m_tag_decl(tag_decl), 45 m_ast_builder(ast_builder), m_index(index), 46 m_decl_to_status(decl_to_status), m_cxx_record_map(cxx_record_map) { 47 CVType cvt = m_index.tpi().getType(m_id.index); 48 switch (cvt.kind()) { 49 case LF_ENUM: 50 m_cvr.er.Options = ClassOptions::None; 51 llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, m_cvr.er)); 52 break; 53 case LF_UNION: 54 m_cvr.ur.Options = ClassOptions::None; 55 llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, m_cvr.ur)); 56 m_layout.bit_size = m_cvr.ur.getSize() * 8; 57 m_record.record.kind = Member::Union; 58 break; 59 case LF_CLASS: 60 case LF_STRUCTURE: 61 m_cvr.cr.Options = ClassOptions::None; 62 llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, m_cvr.cr)); 63 m_layout.bit_size = m_cvr.cr.getSize() * 8; 64 m_record.record.kind = Member::Struct; 65 break; 66 default: 67 llvm_unreachable("unreachable!"); 68 } 69 } 70 71 clang::QualType UdtRecordCompleter::AddBaseClassForTypeIndex( 72 llvm::codeview::TypeIndex ti, llvm::codeview::MemberAccess access, 73 std::optional<uint64_t> vtable_idx) { 74 PdbTypeSymId type_id(ti); 75 clang::QualType qt = m_ast_builder.GetOrCreateType(type_id); 76 77 CVType udt_cvt = m_index.tpi().getType(ti); 78 79 std::unique_ptr<clang::CXXBaseSpecifier> base_spec = 80 m_ast_builder.clang().CreateBaseClassSpecifier( 81 qt.getAsOpaquePtr(), TranslateMemberAccess(access), 82 vtable_idx.has_value(), udt_cvt.kind() == LF_CLASS); 83 if (!base_spec) 84 return {}; 85 86 m_bases.push_back( 87 std::make_pair(vtable_idx.value_or(0), std::move(base_spec))); 88 89 return qt; 90 } 91 92 void UdtRecordCompleter::AddMethod(llvm::StringRef name, TypeIndex type_idx, 93 MemberAccess access, MethodOptions options, 94 MemberAttributes attrs) { 95 clang::QualType method_qt = 96 m_ast_builder.GetOrCreateType(PdbTypeSymId(type_idx)); 97 if (method_qt.isNull()) 98 return; 99 CompilerType method_ct = m_ast_builder.ToCompilerType(method_qt); 100 TypeSystemClang::RequireCompleteType(method_ct); 101 lldb::opaque_compiler_type_t derived_opaque_ty = 102 m_derived_ct.GetOpaqueQualType(); 103 auto iter = m_cxx_record_map.find(derived_opaque_ty); 104 if (iter != m_cxx_record_map.end()) { 105 if (iter->getSecond().contains({name, method_ct})) { 106 return; 107 } 108 } 109 110 lldb::AccessType access_type = TranslateMemberAccess(access); 111 bool is_artificial = (options & MethodOptions::CompilerGenerated) == 112 MethodOptions::CompilerGenerated; 113 m_ast_builder.clang().AddMethodToCXXRecordType( 114 derived_opaque_ty, name.data(), nullptr, method_ct, 115 access_type, attrs.isVirtual(), attrs.isStatic(), false, false, false, 116 is_artificial); 117 118 m_cxx_record_map[derived_opaque_ty].insert({name, method_ct}); 119 } 120 121 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 122 BaseClassRecord &base) { 123 clang::QualType base_qt = 124 AddBaseClassForTypeIndex(base.Type, base.getAccess()); 125 126 if (base_qt.isNull()) 127 return llvm::Error::success(); 128 auto decl = 129 m_ast_builder.clang().GetAsCXXRecordDecl(base_qt.getAsOpaquePtr()); 130 lldbassert(decl); 131 132 auto offset = clang::CharUnits::fromQuantity(base.getBaseOffset()); 133 m_layout.base_offsets.insert(std::make_pair(decl, offset)); 134 135 return llvm::Error::success(); 136 } 137 138 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 139 VirtualBaseClassRecord &base) { 140 AddBaseClassForTypeIndex(base.BaseType, base.getAccess(), base.VTableIndex); 141 142 return Error::success(); 143 } 144 145 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 146 ListContinuationRecord &cont) { 147 return Error::success(); 148 } 149 150 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 151 VFPtrRecord &vfptr) { 152 return Error::success(); 153 } 154 155 Error UdtRecordCompleter::visitKnownMember( 156 CVMemberRecord &cvr, StaticDataMemberRecord &static_data_member) { 157 clang::QualType member_type = 158 m_ast_builder.GetOrCreateType(PdbTypeSymId(static_data_member.Type)); 159 if (member_type.isNull()) 160 return llvm::Error::success(); 161 162 CompilerType member_ct = m_ast_builder.ToCompilerType(member_type); 163 164 lldb::AccessType access = 165 TranslateMemberAccess(static_data_member.getAccess()); 166 auto decl = TypeSystemClang::AddVariableToRecordType( 167 m_derived_ct, static_data_member.Name, member_ct, access); 168 169 // Static constant members may be a const[expr] declaration. 170 // Query the symbol's value as the variable initializer if valid. 171 if (member_ct.IsConst() && member_ct.IsCompleteType()) { 172 std::string qual_name = decl->getQualifiedNameAsString(); 173 174 auto results = 175 m_index.globals().findRecordsByName(qual_name, m_index.symrecords()); 176 177 for (const auto &result : results) { 178 if (result.second.kind() == SymbolKind::S_CONSTANT) { 179 ConstantSym constant(SymbolRecordKind::ConstantSym); 180 cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(result.second, 181 constant)); 182 183 clang::QualType qual_type = decl->getType(); 184 unsigned type_width = decl->getASTContext().getIntWidth(qual_type); 185 unsigned constant_width = constant.Value.getBitWidth(); 186 187 if (qual_type->isIntegralOrEnumerationType()) { 188 if (type_width >= constant_width) { 189 TypeSystemClang::SetIntegerInitializerForVariable( 190 decl, constant.Value.extOrTrunc(type_width)); 191 } else { 192 LLDB_LOG(GetLog(LLDBLog::AST), 193 "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) " 194 "which resolves to a wider constant value ({4} bits). " 195 "Ignoring constant.", 196 m_derived_ct.GetTypeName(), static_data_member.Name, 197 member_ct.GetTypeName(), type_width, constant_width); 198 } 199 } else { 200 lldb::BasicType basic_type_enum = member_ct.GetBasicTypeEnumeration(); 201 switch (basic_type_enum) { 202 case lldb::eBasicTypeFloat: 203 case lldb::eBasicTypeDouble: 204 case lldb::eBasicTypeLongDouble: 205 if (type_width == constant_width) { 206 TypeSystemClang::SetFloatingInitializerForVariable( 207 decl, basic_type_enum == lldb::eBasicTypeFloat 208 ? llvm::APFloat(constant.Value.bitsToFloat()) 209 : llvm::APFloat(constant.Value.bitsToDouble())); 210 decl->setConstexpr(true); 211 } else { 212 LLDB_LOG( 213 GetLog(LLDBLog::AST), 214 "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) " 215 "which resolves to a constant value of mismatched width " 216 "({4} bits). Ignoring constant.", 217 m_derived_ct.GetTypeName(), static_data_member.Name, 218 member_ct.GetTypeName(), type_width, constant_width); 219 } 220 break; 221 default: 222 break; 223 } 224 } 225 break; 226 } 227 } 228 } 229 230 // FIXME: Add a PdbSymUid namespace for field list members and update 231 // the m_uid_to_decl map with this decl. 232 return Error::success(); 233 } 234 235 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 236 NestedTypeRecord &nested) { 237 return Error::success(); 238 } 239 240 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 241 DataMemberRecord &data_member) { 242 243 uint64_t offset = data_member.FieldOffset * 8; 244 uint32_t bitfield_width = 0; 245 246 TypeIndex ti(data_member.Type); 247 if (!ti.isSimple()) { 248 CVType cvt = m_index.tpi().getType(ti); 249 if (cvt.kind() == LF_BITFIELD) { 250 BitFieldRecord bfr; 251 llvm::cantFail(TypeDeserializer::deserializeAs<BitFieldRecord>(cvt, bfr)); 252 offset += bfr.BitOffset; 253 bitfield_width = bfr.BitSize; 254 ti = bfr.Type; 255 } 256 } 257 258 clang::QualType member_qt = m_ast_builder.GetOrCreateType(PdbTypeSymId(ti)); 259 if (member_qt.isNull()) 260 return Error::success(); 261 TypeSystemClang::RequireCompleteType(m_ast_builder.ToCompilerType(member_qt)); 262 lldb::AccessType access = TranslateMemberAccess(data_member.getAccess()); 263 size_t field_size = 264 bitfield_width ? bitfield_width : GetSizeOfType(ti, m_index.tpi()) * 8; 265 if (field_size == 0) 266 return Error::success(); 267 m_record.CollectMember(data_member.Name, offset, field_size, member_qt, access, 268 bitfield_width); 269 return Error::success(); 270 } 271 272 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 273 OneMethodRecord &one_method) { 274 AddMethod(one_method.Name, one_method.Type, one_method.getAccess(), 275 one_method.getOptions(), one_method.Attrs); 276 277 return Error::success(); 278 } 279 280 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 281 OverloadedMethodRecord &overloaded) { 282 TypeIndex method_list_idx = overloaded.MethodList; 283 284 CVType method_list_type = m_index.tpi().getType(method_list_idx); 285 assert(method_list_type.kind() == LF_METHODLIST); 286 287 MethodOverloadListRecord method_list; 288 llvm::cantFail(TypeDeserializer::deserializeAs<MethodOverloadListRecord>( 289 method_list_type, method_list)); 290 291 for (const OneMethodRecord &method : method_list.Methods) 292 AddMethod(overloaded.Name, method.Type, method.getAccess(), 293 method.getOptions(), method.Attrs); 294 295 return Error::success(); 296 } 297 298 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr, 299 EnumeratorRecord &enumerator) { 300 Declaration decl; 301 llvm::StringRef name = DropNameScope(enumerator.getName()); 302 303 m_ast_builder.clang().AddEnumerationValueToEnumerationType( 304 m_derived_ct, decl, name.str().c_str(), enumerator.Value); 305 return Error::success(); 306 } 307 308 void UdtRecordCompleter::complete() { 309 // Ensure the correct order for virtual bases. 310 llvm::stable_sort(m_bases, llvm::less_first()); 311 312 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases; 313 bases.reserve(m_bases.size()); 314 for (auto &ib : m_bases) 315 bases.push_back(std::move(ib.second)); 316 317 TypeSystemClang &clang = m_ast_builder.clang(); 318 // Make sure all base classes refer to complete types and not forward 319 // declarations. If we don't do this, clang will crash with an 320 // assertion in the call to clang_type.TransferBaseClasses() 321 for (const auto &base_class : bases) { 322 clang::TypeSourceInfo *type_source_info = 323 base_class->getTypeSourceInfo(); 324 if (type_source_info) { 325 TypeSystemClang::RequireCompleteType( 326 clang.GetType(type_source_info->getType())); 327 } 328 } 329 330 clang.TransferBaseClasses(m_derived_ct.GetOpaqueQualType(), std::move(bases)); 331 332 clang.AddMethodOverridesForCXXRecordType(m_derived_ct.GetOpaqueQualType()); 333 FinishRecord(); 334 TypeSystemClang::BuildIndirectFields(m_derived_ct); 335 TypeSystemClang::CompleteTagDeclarationDefinition(m_derived_ct); 336 337 if (auto *record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(&m_tag_decl)) { 338 m_ast_builder.GetClangASTImporter().SetRecordLayout(record_decl, m_layout); 339 } 340 } 341 342 uint64_t 343 UdtRecordCompleter::AddMember(TypeSystemClang &clang, Member *field, 344 uint64_t bit_offset, CompilerType parent_ct, 345 ClangASTImporter::LayoutInfo &parent_layout, 346 clang::DeclContext *parent_decl_ctx) { 347 SymbolFileNativePDB *pdb = static_cast<SymbolFileNativePDB *>( 348 clang.GetSymbolFile()->GetBackingSymbolFile()); 349 clang::FieldDecl *field_decl = nullptr; 350 uint64_t bit_size = 0; 351 switch (field->kind) { 352 case Member::Field: { 353 field_decl = TypeSystemClang::AddFieldToRecordType( 354 parent_ct, field->name, m_ast_builder.ToCompilerType(field->qt), 355 field->access, field->bitfield_width); 356 bit_size = field->bit_size; 357 break; 358 }; 359 case Member::Struct: 360 case Member::Union: { 361 clang::TagTypeKind kind = field->kind == Member::Struct 362 ? clang::TagTypeKind::Struct 363 : clang::TagTypeKind::Union; 364 ClangASTMetadata metadata; 365 metadata.SetUserID(pdb->anonymous_id); 366 metadata.SetIsDynamicCXXType(false); 367 CompilerType record_ct = clang.CreateRecordType( 368 parent_decl_ctx, OptionalClangModuleID(), lldb::eAccessPublic, "", 369 llvm::to_underlying(kind), lldb::eLanguageTypeC_plus_plus, &metadata); 370 TypeSystemClang::StartTagDeclarationDefinition(record_ct); 371 ClangASTImporter::LayoutInfo layout; 372 clang::DeclContext *decl_ctx = clang.GetDeclContextForType(record_ct); 373 for (const auto &member : field->fields) { 374 uint64_t member_offset = field->kind == Member::Struct 375 ? member->bit_offset - field->base_offset 376 : 0; 377 uint64_t member_bit_size = AddMember(clang, member.get(), member_offset, 378 record_ct, layout, decl_ctx); 379 if (field->kind == Member::Struct) 380 bit_size = std::max(bit_size, member_offset + member_bit_size); 381 else 382 bit_size = std::max(bit_size, member_bit_size); 383 } 384 layout.bit_size = bit_size; 385 TypeSystemClang::CompleteTagDeclarationDefinition(record_ct); 386 clang::RecordDecl *record_decl = clang.GetAsRecordDecl(record_ct); 387 m_ast_builder.GetClangASTImporter().SetRecordLayout(record_decl, layout); 388 field_decl = TypeSystemClang::AddFieldToRecordType( 389 parent_ct, "", record_ct, lldb::eAccessPublic, 0); 390 // Mark this record decl as completed. 391 DeclStatus status; 392 status.resolved = true; 393 status.uid = pdb->anonymous_id--; 394 m_decl_to_status.insert({record_decl, status}); 395 break; 396 }; 397 } 398 // FIXME: Add a PdbSymUid namespace for field list members and update 399 // the m_uid_to_decl map with this decl. 400 parent_layout.field_offsets.insert({field_decl, bit_offset}); 401 return bit_size; 402 } 403 404 void UdtRecordCompleter::FinishRecord() { 405 TypeSystemClang &clang = m_ast_builder.clang(); 406 clang::DeclContext *decl_ctx = 407 m_ast_builder.GetOrCreateDeclContextForUid(m_id); 408 m_record.ConstructRecord(); 409 // Maybe we should check the construsted record size with the size in pdb. If 410 // they mismatch, it might be pdb has fields info missing. 411 for (const auto &field : m_record.record.fields) { 412 AddMember(clang, field.get(), field->bit_offset, m_derived_ct, m_layout, 413 decl_ctx); 414 } 415 } 416 417 void UdtRecordCompleter::Record::CollectMember( 418 llvm::StringRef name, uint64_t offset, uint64_t field_size, 419 clang::QualType qt, lldb::AccessType access, uint64_t bitfield_width) { 420 fields_map[offset].push_back(std::make_unique<Member>( 421 name, offset, field_size, qt, access, bitfield_width)); 422 if (start_offset > offset) 423 start_offset = offset; 424 } 425 426 void UdtRecordCompleter::Record::ConstructRecord() { 427 // For anonymous unions in a struct, msvc generated pdb doesn't have the 428 // entity for that union. So, we need to construct anonymous union and struct 429 // based on field offsets. The final AST is likely not matching the exact 430 // original AST, but the memory layout is preseved. 431 // After we collecting all fields in visitKnownMember, we have all fields in 432 // increasing offset order in m_fields. Since we are iterating in increase 433 // offset order, if the current offset is equal to m_start_offset, we insert 434 // it as direct field of top level record. If the current offset is greater 435 // than m_start_offset, we should be able to find a field in end_offset_map 436 // whose end offset is less than or equal to current offset. (if not, it might 437 // be missing field info. We will ignore the field in this case. e.g. Field A 438 // starts at 0 with size 4 bytes, and Field B starts at 2 with size 4 bytes. 439 // Normally, there must be something which ends at/before 2.) Then we will 440 // append current field to the end of parent record. If parent is struct, we 441 // can just grow it. If parent is a field, it's a field inside an union. We 442 // convert it into an anonymous struct containing old field and new field. 443 444 // The end offset to a vector of field/struct that ends at the offset. 445 std::map<uint64_t, std::vector<Member *>> end_offset_map; 446 for (auto &pair : fields_map) { 447 uint64_t offset = pair.first; 448 auto &fields = pair.second; 449 lldbassert(offset >= start_offset); 450 Member *parent = &record; 451 if (offset > start_offset) { 452 // Find the field with largest end offset that is <= offset. If it's less 453 // than offset, it indicates there are padding bytes between end offset 454 // and offset. 455 lldbassert(!end_offset_map.empty()); 456 auto iter = end_offset_map.lower_bound(offset); 457 if (iter == end_offset_map.end()) 458 --iter; 459 else if (iter->first > offset) { 460 if (iter == end_offset_map.begin()) 461 continue; 462 --iter; 463 } 464 if (iter->second.empty()) 465 continue; 466 parent = iter->second.back(); 467 iter->second.pop_back(); 468 } 469 // If it's a field, then the field is inside a union, so we can safely 470 // increase its size by converting it to a struct to hold multiple fields. 471 if (parent->kind == Member::Field) 472 parent->ConvertToStruct(); 473 474 if (fields.size() == 1) { 475 uint64_t end_offset = offset + fields.back()->bit_size; 476 parent->fields.push_back(std::move(fields.back())); 477 if (parent->kind == Member::Struct) { 478 end_offset_map[end_offset].push_back(parent); 479 } else { 480 lldbassert(parent == &record && 481 "If parent is union, it must be the top level record."); 482 end_offset_map[end_offset].push_back(parent->fields.back().get()); 483 } 484 } else { 485 if (parent->kind == Member::Struct) { 486 parent->fields.push_back(std::make_unique<Member>(Member::Union)); 487 parent = parent->fields.back().get(); 488 parent->bit_offset = offset; 489 } else { 490 lldbassert(parent == &record && 491 "If parent is union, it must be the top level record."); 492 } 493 for (auto &field : fields) { 494 int64_t bit_size = field->bit_size; 495 parent->fields.push_back(std::move(field)); 496 end_offset_map[offset + bit_size].push_back( 497 parent->fields.back().get()); 498 } 499 } 500 } 501 } 502