43#include "clang/AST/CXXInheritance.h"
44#include "clang/AST/DeclBase.h"
45#include "clang/AST/DeclCXX.h"
46#include "clang/AST/DeclObjC.h"
47#include "clang/AST/DeclTemplate.h"
48#include "clang/AST/Type.h"
49#include "clang/Basic/Specifiers.h"
50#include "llvm/ADT/StringExtras.h"
51#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
52#include "llvm/DebugInfo/DWARF/DWARFTypePrinter.h"
53#include "llvm/Demangle/Demangle.h"
63using namespace llvm::dwarf;
73 case clang::Decl::CXXRecord:
74 case clang::Decl::ClassTemplateSpecialization:
95 while (Parent.IsValid()) {
96 if (Parent.Tag() == DW_TAG_module)
98 Parent = Parent.GetParent();
109 parent = parent.GetParent()) {
111 if (tag == DW_TAG_module)
112 top_module_die = parent;
113 else if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
117 return top_module_die;
126 if (clang_module_die) {
127 const char *module_name = clang_module_die.
GetName();
139 return FieldName.starts_with(
"_vptr$")
141 || FieldName.starts_with(
"_vptr.");
147 case DW_TAG_class_type:
148 case DW_TAG_structure_type:
149 case DW_TAG_union_type:
160 assert(subprogram.
Tag() == DW_TAG_subprogram ||
161 subprogram.
Tag() == DW_TAG_inlined_subroutine ||
162 subprogram.
Tag() == DW_TAG_subroutine_type);
167 std::optional<size_t> object_pointer_index;
169 if (subprogram.
GetDIE()->GetAttributeValue(
170 subprogram.
GetCU(), DW_AT_object_pointer, form_value,
175 object_pointer_index = form_value.
Unsigned();
180 size_t param_index = 0;
181 for (
const auto &child : subprogram.
children()) {
182 if (child.Tag() != DW_TAG_formal_parameter)
185 if (param_index == object_pointer_index.value_or(0)) {
186 object_pointer = child;
200 if (object_pointer_index)
201 return object_pointer;
216 if (
const char *name = object_pointer.
GetName();
217 name && ::strcmp(name,
"this") != 0)
220 return object_pointer;
228 if (!subprogram || !object_parameter)
237 unsigned cv_quals = 0;
239 cv_quals |= clang::Qualifiers::Const;
241 cv_quals |= clang::Qualifiers::Volatile;
259 auto *obj = sym->GetMainObjectFile();
263 auto module_sp = obj->GetModule();
267 return module_sp->GetID();
272 module_id = get_module_id(
dwarf);
277 const auto die_id = die.
GetID();
293 if (!clang_module_sp)
299 std::vector<lldb_private::CompilerContext> die_context = die.
GetDeclContext();
300 TypeQuery query(die_context, TypeQueryOptions::e_module_search |
301 TypeQueryOptions::e_find_one);
306 clang_module_sp->FindTypes(query, results);
318 sym_file.ForEachExternalModule(
320 module.FindTypes(query, results);
321 pcm_type_sp = results.GetTypeMap().FirstType();
322 return (bool)pcm_type_sp;
352 auto type_sp =
dwarf->MakeType(
353 die.
GetID(), pcm_type_sp->GetName(),
354 llvm::expectedToOptional(pcm_type_sp->GetByteSize(
nullptr)),
nullptr,
376 clang::DeclContext *decl_ctx,
378 const char *type_name_cstr) {
379 auto *tag_decl_ctx = clang::dyn_cast<clang::TagDecl>(decl_ctx);
384 if (tag_decl_ctx->isCompleteDefinition() || tag_decl_ctx->isBeingDefined())
392 if (type && ast_importer.
CanImport(type)) {
397 "Unable to complete the Decl context for DIE {0} at offset {1:x16}",
398 type_name_cstr ? type_name_cstr :
"", die.
GetOffset());
407 if (!tag_decl_ctx->hasExternalLexicalStorage()) {
415 for (
size_t i = 0; i < attributes.
Size(); ++i) {
423 case DW_AT_abstract_origin:
427 case DW_AT_artificial:
431 case DW_AT_bit_stride:
435 case DW_AT_byte_size:
443 case DW_AT_alignment:
447 case DW_AT_byte_stride:
451 case DW_AT_calling_convention:
455 case DW_AT_containing_type:
459 case DW_AT_decl_file:
464 case DW_AT_decl_line:
467 case DW_AT_decl_column:
471 case DW_AT_address_class: {
472 uint64_t val = form_value.
Unsigned();
473 if (val == llvm::dwarf::DW_ADDR_none)
475 constexpr uint64_t max_target_as =
476 clang::Qualifiers::MaxAddressSpace -
477 llvm::to_underlying(clang::LangAS::FirstTargetAddressSpace);
478 if (val <= max_target_as) {
480 clang::getLangASFromTargetAS(
static_cast<unsigned>(val));
483 "[{0:x16}]: invalid DW_AT_address_class {1:x}", die.
GetOffset(),
489 case DW_AT_declaration:
497 case DW_AT_enum_class:
514 case DW_AT_linkage_name:
515 case DW_AT_MIPS_linkage_name:
523 case DW_AT_signature:
527 case DW_AT_specification:
535 case DW_AT_virtuality:
539 case DW_AT_APPLE_objc_complete_type:
543 case DW_AT_APPLE_objc_direct:
547 case DW_AT_APPLE_runtime_class:
551 case DW_AT_GNU_vector:
554 case DW_AT_export_symbols:
557 case DW_AT_rvalue_reference:
560 case DW_AT_reference:
563 case DW_AT_APPLE_enum_kind:
564 enum_kind =
static_cast<clang::EnumExtensibilityAttr::Kind
>(
573 return unit->GetAbsolutePath().GetPath();
574 return "<missing DWARF unit path>";
579 bool *type_is_new_ptr) {
581 *type_is_new_ptr =
false;
591 clang::DeclContext *context =
594 dwarf->GetObjectFile()->GetModule()->LogMessage(
596 "DWARFASTParserClang::ParseTypeFromDWARF "
597 "(die = {0:x16}, decl_ctx = {1:p} (die "
598 "{2:x16})) {3} ({4}) name = '{5}')",
604 if (
auto [it, inserted] =
609 return it->getSecond()->shared_from_this();
618 if (clang::DeclContext *decl_ctx =
624 *type_is_new_ptr =
true;
630 case DW_TAG_template_alias:
631 case DW_TAG_base_type:
632 case DW_TAG_pointer_type:
633 case DW_TAG_reference_type:
634 case DW_TAG_rvalue_reference_type:
635 case DW_TAG_const_type:
636 case DW_TAG_restrict_type:
637 case DW_TAG_volatile_type:
638 case DW_TAG_LLVM_ptrauth_type:
639 case DW_TAG_atomic_type:
640 case DW_TAG_unspecified_type:
643 case DW_TAG_structure_type:
644 case DW_TAG_union_type:
645 case DW_TAG_class_type:
648 case DW_TAG_enumeration_type:
651 case DW_TAG_inlined_subroutine:
652 case DW_TAG_subprogram:
653 case DW_TAG_subroutine_type:
656 case DW_TAG_array_type:
659 case DW_TAG_ptr_to_member_type:
663 dwarf->GetObjectFile()->GetModule()->ReportInternalError(
664 "[{0:x16}]: unhandled type tag {1:x4} ({2})", die.
GetOffset(), tag,
671 dwarf->GetDIEToType()[die.
GetDIE()] = type_sp.get();
676static std::optional<uint32_t>
687 Value initialValue(0);
689 uint32_t block_length = form_value.
Unsigned();
690 uint32_t block_offset =
700 "ExtractDataMemberLocation failed: {0}");
704 return memberOffset->GetScalar().UInt();
708 auto getAttr = [&](llvm::dwarf::Attribute Attr,
unsigned defaultValue = 0) {
711 const unsigned key = getAttr(DW_AT_LLVM_ptrauth_key);
712 const bool addr_disc = getAttr(DW_AT_LLVM_ptrauth_address_discriminated);
713 const unsigned extra = getAttr(DW_AT_LLVM_ptrauth_extra_discriminator);
714 const bool isapointer = getAttr(DW_AT_LLVM_ptrauth_isa_pointer);
715 const bool authenticates_null_values =
716 getAttr(DW_AT_LLVM_ptrauth_authenticates_null_values);
717 const unsigned authentication_mode_int = getAttr(
718 DW_AT_LLVM_ptrauth_authentication_mode,
719 static_cast<unsigned>(clang::PointerAuthenticationMode::SignAndAuth));
720 clang::PointerAuthenticationMode authentication_mode =
721 clang::PointerAuthenticationMode::SignAndAuth;
722 if (authentication_mode_int >=
723 static_cast<unsigned>(clang::PointerAuthenticationMode::None) &&
724 authentication_mode_int <=
725 static_cast<unsigned>(
726 clang::PointerAuthenticationMode::SignAndAuth)) {
727 authentication_mode =
728 static_cast<clang::PointerAuthenticationMode
>(authentication_mode_int);
731 "[{0:x16}]: invalid pointer authentication mode method {1:x4}",
732 die.
GetOffset(), authentication_mode_int);
734 auto ptr_auth = clang::PointerAuthQualifier::Create(
735 key, addr_disc, extra, authentication_mode, isapointer,
736 authenticates_null_values);
754 if (tag == DW_TAG_typedef || tag == DW_TAG_template_alias) {
806 case DW_TAG_unspecified_type:
807 if (attrs.
name ==
"nullptr_t" || attrs.
name ==
"decltype(nullptr)") {
816 case DW_TAG_base_type: {
824 clang_type =
m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize(
828 case DW_TAG_pointer_type:
832 case DW_TAG_reference_type:
835 case DW_TAG_rvalue_reference_type:
839 case DW_TAG_template_alias:
842 case DW_TAG_const_type:
845 case DW_TAG_restrict_type:
848 case DW_TAG_volatile_type:
851 case DW_TAG_LLVM_ptrauth_type:
855 case DW_TAG_atomic_type:
862 if (tag == DW_TAG_pointer_type) {
870 if (!strcmp(child_die.GetAttributeValueAsString(DW_AT_name,
""),
875 if (function_pointer_type) {
879 bool function_type_is_new_pointer;
881 sc, function_type, &function_type_is_new_pointer);
883 if (lldb_function_type_sp) {
884 clang_type =
m_ast.CreateBlockPointerType(
885 lldb_function_type_sp->GetForwardCompilerType());
901 if (attrs.
name ==
"id") {
903 dwarf->GetObjectFile()->GetModule()->LogMessage(
905 "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' "
906 "is Objective-C 'id' built-in type.",
913 }
else if (attrs.
name ==
"Class") {
915 dwarf->GetObjectFile()->GetModule()->LogMessage(
917 "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' "
918 "is Objective-C 'Class' built-in type.",
925 }
else if (attrs.
name ==
"SEL") {
927 dwarf->GetObjectFile()->GetModule()->LogMessage(
929 "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' "
930 "is Objective-C 'selector' built-in type.",
945 if (encoding_die && encoding_die.
Tag() == DW_TAG_structure_type) {
946 llvm::StringRef struct_name = encoding_die.
GetName();
947 if (struct_name ==
"objc_object") {
949 dwarf->GetObjectFile()->GetModule()->LogMessage(
951 "SymbolFileDWARF::ParseType (die = {0:x16}) {1} ({2}) '{3}' "
952 "is 'objc_object*', which we overrode to 'id'.",
967 &attrs.
decl, clang_type, resolve_state, payload);
974 if (llvm::StringRef(die.
GetName()).contains(
"<"))
978 llvm::raw_string_ostream os(name);
979 llvm::DWARFTypePrinter<DWARFDIE> type_printer(os);
980 type_printer.appendAndTerminateTemplateParameters(die);
995 unique_typename, decl_declaration);
997 dwarf->GetUniqueDWARFASTTypeMap().Find(
998 unique_typename, decl_die, decl_declaration,
1001 unique_ast_entry_type->UpdateToDefDIE(def_die, def_attrs.
decl,
1006 "Failed to find {0:x16} {1} ({2}) type \"{3}\" in "
1007 "UniqueDWARFASTTypeMap",
1024 def_die =
dwarf->FindDefinitionDIE(decl_die);
1028 if (debug_map_symfile) {
1036 dwarf->GetObjectFile()->GetModule()->LogMessage(
1038 "SymbolFileDWARF({0:p}) - {1:x16}}: {2} ({3}) type \"{4}\" is a "
1039 "forward declaration, complete DIE is {5}",
1042 def_die ? llvm::utohexstr(def_die.
GetID()) :
"not found");
1046 if (
auto [it, inserted] =
dwarf->GetDIEToType().try_emplace(
1051 return it->getSecond()->shared_from_this();
1062 Type *enumerator_type =
1064 if (enumerator_type)
1068 if (!enumerator_clang_type) {
1070 enumerator_clang_type =
m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize(
1071 "", DW_ATE_signed, *attrs.
byte_size * 8);
1088 clang::DeclContext *type_decl_ctx =
1091 if (decl_die != def_die) {
1093 dwarf->GetDIEToType()[def_die.
GetDIE()] = type_sp.get();
1098 dwarf->GetObjectFile()->GetModule()->ReportInternalError(
1099 "DWARF DIE at {0:x16} named \"{1}\" was not able to start its "
1106static clang::CallingConv
1109 case llvm::dwarf::DW_CC_normal:
1111 case llvm::dwarf::DW_CC_BORLAND_stdcall:
1112 return clang::CC_X86StdCall;
1113 case llvm::dwarf::DW_CC_BORLAND_msfastcall:
1114 return clang::CC_X86FastCall;
1115 case llvm::dwarf::DW_CC_LLVM_vectorcall:
1116 return clang::CC_X86VectorCall;
1117 case llvm::dwarf::DW_CC_BORLAND_pascal:
1118 return clang::CC_X86Pascal;
1119 case llvm::dwarf::DW_CC_LLVM_Win64:
1120 return clang::CC_Win64;
1121 case llvm::dwarf::DW_CC_LLVM_X86_64SysV:
1122 return clang::CC_X86_64SysV;
1123 case llvm::dwarf::DW_CC_LLVM_X86RegCall:
1124 return clang::CC_X86RegCall;
1130 LLDB_LOG(log,
"Unsupported DW_AT_calling_convention value: {0}",
1143 const auto tag = die.
Tag();
1148 TypeSP complete_objc_class_type_sp =
1149 dwarf->FindCompleteObjCDefinitionTypeForDIE(
DWARFDIE(), class_name,
1152 if (!complete_objc_class_type_sp)
1156 complete_objc_class_type_sp->GetForwardCompilerType();
1158 if (!type_clang_forward_type)
1164 clang::ObjCMethodDecl *objc_method_decl =
m_ast.AddMethodToObjCObjectType(
1168 if (!objc_method_decl) {
1169 dwarf->GetObjectFile()->GetModule()->ReportInternalError(
1170 "[{0:x16}]: invalid Objective-C method {1:x4} ({2})", die.
GetOffset(),
1176 m_ast.SetMetadataAsUserID(objc_method_decl, die.
GetID());
1184 const DWARFDIE &object_parameter,
bool &ignore_containing_context) {
1189 Type *class_type =
dwarf->ResolveType(decl_ctx_die);
1193 if (class_type->
GetID() != decl_ctx_die.
GetID() ||
1200 std::vector<DWARFDIE> failures;
1212 return {
true, type_ptr->shared_from_this()};
1226 clang::DeclContext *spec_clang_decl_ctx =
1228 if (spec_clang_decl_ctx)
1231 dwarf->GetObjectFile()->GetModule()->ReportWarning(
1232 "{0:x8}: DW_AT_specification({1:x16}"
1236 return {
true,
nullptr};
1248 if (abs_clang_decl_ctx)
1251 dwarf->GetObjectFile()->GetModule()->ReportWarning(
1252 "{0:x8}: DW_AT_abstract_origin({1:x16}"
1256 return {
true,
nullptr};
1269 const bool is_static = !object_parameter.
IsValid();
1275 return {
true,
nullptr};
1277 const bool is_attr_used =
false;
1279 clang::CXXMethodDecl *cxx_method_decl =
m_ast.AddMethodToCXXRecordType(
1284 if (cxx_method_decl) {
1290 if (
char const *object_pointer_name = object_parameter.
GetName()) {
1292 LLDB_LOGF(log,
"Setting object pointer name: %s on method object %p.\n",
1293 object_pointer_name,
static_cast<void *
>(cxx_method_decl));
1295 m_ast.SetMetadata(cxx_method_decl, metadata);
1297 ignore_containing_context =
true;
1302 const bool type_handled = cxx_method_decl !=
nullptr || attrs.
is_artificial;
1304 return {type_handled,
nullptr};
1315 bool is_variadic =
false;
1316 bool has_template_params =
false;
1319 Type *func_type =
nullptr;
1329 std::vector<CompilerType> function_param_types;
1330 llvm::SmallVector<llvm::StringRef> function_param_names;
1335 clang::DeclContext *containing_decl_ctx =
1337 assert(containing_decl_ctx);
1341 has_template_params, function_param_types,
1342 function_param_names);
1346 bool ignore_containing_context =
false;
1357 if (is_cxx_method && has_template_params) {
1358 ignore_containing_context =
true;
1359 is_cxx_method =
false;
1362 clang::CallingConv calling_convention =
1370 return_clang_type, function_param_types, is_variadic,
1375 bool type_handled =
false;
1376 if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
1377 if (std::optional<const ObjCLanguage::ObjCMethodName> objc_method =
1382 }
else if (is_cxx_method) {
1383 auto [handled, type_sp] =
1385 object_parameter, ignore_containing_context);
1389 type_handled = handled;
1393 if (!type_handled) {
1394 clang::FunctionDecl *function_decl =
nullptr;
1395 clang::FunctionDecl *template_function_decl =
nullptr;
1400 if (
dwarf->ResolveType(abs_die)) {
1401 function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(
1404 if (function_decl) {
1410 if (!function_decl) {
1411 char *name_buf =
nullptr;
1418 llvm::ItaniumPartialDemangler D;
1420 name_buf = D.getFunctionBaseName(
nullptr,
nullptr);
1426 function_decl =
m_ast.CreateFunctionDeclaration(
1427 ignore_containing_context ?
m_ast.GetTranslationUnitDecl()
1428 : containing_decl_ctx,
1431 std::free(name_buf);
1433 if (has_template_params) {
1436 template_function_decl =
m_ast.CreateFunctionDeclaration(
1437 ignore_containing_context ?
m_ast.GetTranslationUnitDecl()
1438 : containing_decl_ctx,
1441 clang::FunctionTemplateDecl *func_template_decl =
1442 m_ast.CreateFunctionTemplateDecl(
1444 template_function_decl, template_param_infos);
1445 m_ast.CreateFunctionTemplateSpecializationInfo(
1446 template_function_decl, func_template_decl, template_param_infos);
1451 if (function_decl) {
1454 const clang::FunctionProtoType *function_prototype(
1455 llvm::cast<clang::FunctionProtoType>(
1457 const auto params =
m_ast.CreateParameterDeclarations(
1458 function_decl, *function_prototype, function_param_names);
1459 function_decl->setParams(params);
1460 if (template_function_decl)
1461 template_function_decl->setParams(params);
1466 if (
char const *object_pointer_name = object_parameter.
GetName()) {
1469 "Setting object pointer name: %s on function "
1471 object_pointer_name,
static_cast<void *
>(function_decl));
1473 m_ast.SetMetadata(function_decl, metadata);
1478 return dwarf->MakeType(
1489 Type *element_type =
dwarf->ResolveTypeUID(type_die,
true);
1498 byte_stride = array_info->byte_stride;
1499 bit_stride = array_info->bit_stride;
1501 if (byte_stride == 0 && bit_stride == 0)
1502 byte_stride = llvm::expectedToOptional(element_type->
GetByteSize(
nullptr))
1507 uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride;
1509 if (array_info && array_info->element_orders.size() > 0) {
1510 auto end = array_info->element_orders.rend();
1511 for (
auto pos = array_info->element_orders.rbegin(); pos != end; ++pos) {
1512 clang_type =
m_ast.CreateArrayType(
1513 array_element_type, *pos, attrs.
is_vector);
1515 uint64_t num_elements = pos->value_or(0);
1516 array_element_type = clang_type;
1517 array_element_bit_stride = num_elements
1518 ? array_element_bit_stride * num_elements
1519 : array_element_bit_stride;
1522 clang_type =
m_ast.CreateArrayType(
1523 array_element_type, std::nullopt, attrs.
is_vector);
1527 dwarf->MakeType(die.
GetID(), empty_name, array_element_bit_stride / 8,
1530 type_sp->SetEncodingType(element_type);
1532 m_ast.SetMetadataAsUserID(type, die.
GetID());
1545 if ((class_type ==
nullptr) || (pointee_type ==
nullptr))
1552 class_clang_type, pointee_clang_type);
1554 if (std::optional<uint64_t> clang_type_size =
1555 llvm::expectedToOptional(clang_type.
GetByteSize(
nullptr))) {
1556 return dwarf->MakeType(die.
GetID(), attrs.
name, *clang_type_size,
nullptr,
1564 switch (die.
Tag()) {
1565 case DW_TAG_union_type:
1566 case DW_TAG_structure_type:
1568 case DW_TAG_class_type:
1578 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
1586 if (attributes.
Size() == 0)
1591 bool is_virtual =
false;
1592 bool is_base_of_class =
true;
1593 off_t member_byte_offset = 0;
1595 for (uint32_t i = 0; i < attributes.
Size(); ++i) {
1601 encoding_form = form_value;
1603 case DW_AT_data_member_location:
1604 if (
auto maybe_offset =
1606 member_byte_offset = *maybe_offset;
1608 case DW_AT_accessibility:
1612 case DW_AT_virtuality:
1613 is_virtual = form_value.
Boolean();
1623 if (base_class_type ==
nullptr) {
1624 module_sp->ReportInternalError(
"{0:x16}: DW_TAG_inheritance failed to "
1625 "resolve the base class at {1:x16}"
1626 " from enclosing type {2:x16}",
1634 assert(base_class_clang_type);
1642 ast->SetObjCSuperClass(class_clang_type, base_class_clang_type);
1645 std::unique_ptr<clang::CXXBaseSpecifier> result =
1647 accessibility, is_virtual,
1652 base_classes.push_back(std::move(result));
1670 clang::CharUnits::fromQuantity(member_byte_offset)));
1683 if (sc_parent_tag == DW_TAG_compile_unit ||
1684 sc_parent_tag == DW_TAG_partial_unit) {
1686 }
else if (sc.
function !=
nullptr && sc_parent_die) {
1687 symbol_context_scope =
1689 if (symbol_context_scope ==
nullptr)
1690 symbol_context_scope = sc.
function;
1692 symbol_context_scope = sc.
module_sp.get();
1695 if (symbol_context_scope !=
nullptr)
1696 type_sp->SetSymbolContextScope(symbol_context_scope);
1713 decl_declaration.
Clear();
1714 std::string qualified_name;
1717 while (parent_decl_ctx_die) {
1721 const dw_tag_t parent_tag = parent_decl_ctx_die.
Tag();
1722 switch (parent_tag) {
1723 case DW_TAG_namespace: {
1724 if (
const char *namespace_name = parent_decl_ctx_die.
GetName()) {
1725 qualified_name.insert(0,
"::");
1726 qualified_name.insert(0, namespace_name);
1728 qualified_name.insert(0,
"(anonymous namespace)::");
1734 case DW_TAG_class_type:
1735 case DW_TAG_structure_type:
1736 case DW_TAG_union_type: {
1737 if (
const char *class_union_struct_name = parent_decl_ctx_die.
GetName()) {
1738 qualified_name.insert(0,
"::");
1739 qualified_name.insert(0,
1741 qualified_name.insert(0, class_union_struct_name);
1748 parent_decl_ctx_die.
Clear();
1753 if (qualified_name.empty())
1754 qualified_name.append(
"::");
1756 qualified_name.append(unique_typename.
GetCString());
1765 clang::ObjCInterfaceDecl *decl =
1769 if (
const char *runtime_name =
1771 .GetAttributeValueAsString(DW_AT_const_value,
nullptr))
1772 decl->addAttr(clang::ObjCRuntimeNameAttr::CreateImplicit(
1773 decl->getASTContext(), runtime_name));
1787 uint64_t byte_size = attrs.
byte_size.value_or(0);
1793 dwarf->GetObjectFile()->GetModule()->LogMessage(
1794 log,
"SymbolFileDWARF({0:p}) - {1:x16}: {2} has unique name: {3} ",
1799 dwarf->GetUniqueDWARFASTTypeMap().Find(
1800 unique_typename, die, unique_decl, byte_size,
1802 if (
TypeSP type_sp = unique_ast_entry_type->m_type_sp) {
1803 dwarf->GetDIEToType()[die.
GetDIE()] = type_sp.get();
1810 unique_ast_entry_type->m_is_forward_declaration) {
1811 unique_ast_entry_type->UpdateToDefDIE(die, unique_decl, byte_size);
1812 clang_type = type_sp->GetForwardCompilerType();
1816 dwarf->GetForwardDeclCompilerTypeToDIE().insert_or_assign(
1834 dwarf->FindCompleteObjCDefinitionTypeForDIE(die, attrs.
name,
true);
1838 if (debug_map_symfile) {
1842 die, attrs.
name,
true);
1848 dwarf->GetObjectFile()->GetModule()->LogMessage(
1850 "SymbolFileDWARF({0:p}) - {1:x16}: {2} ({3}) type \"{4}\" is an "
1851 "incomplete objc type, complete type is {5:x8}",
1867 int tag_decl_kind = -1;
1868 if (tag == DW_TAG_structure_type)
1869 tag_decl_kind = llvm::to_underlying(clang::TagTypeKind::Struct);
1870 else if (tag == DW_TAG_union_type)
1871 tag_decl_kind = llvm::to_underlying(clang::TagTypeKind::Union);
1872 else if (tag == DW_TAG_class_type)
1873 tag_decl_kind = llvm::to_underlying(clang::TagTypeKind::Class);
1875 assert(
false &&
"Unexpected tag kind.");
1877 clang::DeclContext *containing_decl_ctx =
1881 containing_decl_ctx, die,
1891 clang::ClassTemplateDecl *class_template_decl =
1892 m_ast.ParseClassTemplateDecl(
1895 if (!class_template_decl) {
1897 dwarf->GetObjectFile()->GetModule()->LogMessage(
1899 "SymbolFileDWARF({0:p}) - {1:x16}: {2} ({3}) type \"{4}\" "
1900 "clang::ClassTemplateDecl failed to return a decl.",
1907 clang::ClassTemplateSpecializationDecl *class_specialization_decl =
1908 m_ast.CreateClassTemplateSpecializationDecl(
1910 tag_decl_kind, template_param_infos);
1911 if (!class_specialization_decl) {
1913 dwarf->GetObjectFile()->GetModule()->LogMessage(
1915 "SymbolFileDWARF({0:p}) - Failed to create specialization for "
1916 "clang::ClassTemplateDecl({1}, {2:p}).",
1917 this, llvm::StringRef(attrs.
name), class_template_decl);
1923 m_ast.CreateClassTemplateSpecializationType(class_specialization_decl);
1925 m_ast.SetMetadata(class_template_decl, metadata);
1926 m_ast.SetMetadata(class_specialization_decl, metadata);
1930 clang_type =
m_ast.CreateRecordType(
1945 clang::DeclContext *type_decl_ctx =
1953 auto unique_ast_entry_up = std::make_unique<UniqueDWARFASTType>();
1957 unique_ast_entry_up->m_type_sp = type_sp;
1958 unique_ast_entry_up->m_die = die;
1959 unique_ast_entry_up->m_declaration = unique_decl;
1960 unique_ast_entry_up->m_byte_size = byte_size;
1962 dwarf->GetUniqueDWARFASTTypeMap().Insert(unique_typename,
1963 *unique_ast_entry_up);
1971 dwarf->GetForwardDeclCompilerTypeToDIE()
1976 assert(inserted &&
"Type already in the forward declaration map!");
1985 clang::CXXRecordDecl *record_decl =
1987 if (record_decl && record_decl->getDefinition()) {
1988 record_decl->setHasTrivialSpecialMemberForCall();
1993 clang::CXXRecordDecl *record_decl =
1996 record_decl->setArgPassingRestrictions(
1997 clang::RecordArgPassingKind::CannotPassInRegs);
2007 const CompilerType &class_opaque_type,
const char *property_name,
2011 const char *property_setter_name,
const char *property_getter_name,
2036static std::optional<clang::APValue>
MakeAPValue(
const clang::ASTContext &ast,
2039 std::optional<uint64_t> bit_width =
2040 llvm::expectedToOptional(clang_type.
GetBitSize(
nullptr));
2042 return std::nullopt;
2044 bool is_signed =
false;
2047 llvm::APSInt apint(*bit_width, !is_signed);
2051 return clang::APValue(apint);
2056 return std::nullopt;
2058 return clang::APValue(llvm::APFloat(
2066 bool is_template_template_argument =
false;
2069 case DW_TAG_GNU_template_parameter_pack: {
2071 std::make_unique<TypeSystemClang::TemplateParameterInfos>());
2076 if (
const char *name = die.
GetName()) {
2081 case DW_TAG_GNU_template_template_param:
2082 is_template_template_argument =
true;
2084 case DW_TAG_template_type_parameter:
2085 case DW_TAG_template_value_parameter: {
2087 if (attributes.
Size() == 0)
2090 const char *name =
nullptr;
2091 const char *template_name =
nullptr;
2093 uint64_t uval64 = 0;
2094 bool uval64_valid =
false;
2095 bool is_default_template_arg =
false;
2097 for (
size_t i = 0; i < attributes.
Size(); ++i) {
2106 case DW_AT_GNU_template_name:
2119 case DW_AT_const_value:
2121 uval64_valid =
true;
2125 case DW_AT_default_value:
2127 is_default_template_arg = form_value.
Boolean();
2134 clang::ASTContext &ast =
m_ast.getASTContext();
2138 if (!is_template_template_argument) {
2140 if (name && !name[0])
2143 if (tag == DW_TAG_template_value_parameter && uval64_valid) {
2144 if (
auto value =
MakeAPValue(ast, clang_type, uval64)) {
2146 name, clang::TemplateArgument(
2148 std::move(*value), is_default_template_arg));
2158 is_default_template_arg));
2160 auto *tplt_type =
m_ast.CreateTemplateTemplateParmDecl(template_name);
2162 name, clang::TemplateArgument(clang::TemplateName(tplt_type),
2163 is_default_template_arg));
2185 case DW_TAG_template_type_parameter:
2186 case DW_TAG_template_value_parameter:
2187 case DW_TAG_GNU_template_parameter_pack:
2188 case DW_TAG_GNU_template_template_param:
2197 return !template_param_infos.
IsEmpty() ||
2206 std::vector<DWARFDIE> contained_type_dies;
2217 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
2219 std::vector<DWARFDIE> member_function_dies;
2223 contained_type_dies, delayed_properties, layout_info);
2226 for (
const DWARFDIE &die : member_function_dies)
2227 dwarf->ResolveType(die);
2232 dwarf->GetObjCMethods(class_name, [&](
DWARFDIE method_die) {
2238 property.Finalize();
2248 "WARNING: Type completion aborted because forward declaration for "
2249 "'{0}' is C++ while definition is Objective-C.",
2250 llvm::StringRef(die.
GetName()));
2266 clang::CXXRecordDecl *record_decl =
2274 if (
m_ast.getASTContext().getTargetInfo().getCXXABI().isMicrosoft()) {
2275 auto IM = record_decl->calculateInheritanceModel();
2276 record_decl->addAttr(clang::MSInheritanceAttr::CreateImplicit(
2277 m_ast.getASTContext(),
true, {},
2278 clang::MSInheritanceAttr::Spelling(IM)));
2285 for (
const DWARFDIE &die : contained_type_dies)
2286 dwarf->ResolveType(die);
2288 return (
bool)clang_type;
2300 llvm::expectedToOptional(type->
GetByteSize(
nullptr)).value_or(0),
2305 return (
bool)clang_type;
2313 std::lock_guard<std::recursive_mutex> guard(
2314 dwarf->GetObjectFile()->GetModule()->GetMutex());
2327 case DW_TAG_structure_type:
2328 case DW_TAG_union_type:
2329 case DW_TAG_class_type:
2332 case DW_TAG_enumeration_type:
2336 assert(
false &&
"not a forward clang type decl!");
2353 auto opaque_decl_ctx =
2364 if (clang_decl !=
nullptr)
2365 return m_ast.GetCompilerDecl(clang_decl);
2373 return m_ast.CreateDeclContext(clang_decl_ctx);
2379 clang::DeclContext *clang_decl_ctx =
2382 return m_ast.CreateDeclContext(clang_decl_ctx);
2388 uint32_t enumerator_byte_size,
const DWARFDIE &parent_die) {
2392 size_t enumerators_added = 0;
2396 if (tag != DW_TAG_enumerator)
2400 if (attributes.
Size() == 0)
2403 const char *name =
nullptr;
2404 std::optional<uint64_t> enum_value;
2407 for (
size_t i = 0; i < attributes.
Size(); ++i) {
2412 case DW_AT_const_value:
2414 enum_value = form_value.
Signed();
2416 enum_value = form_value.
Unsigned();
2423 case DW_AT_description:
2425 case DW_AT_decl_file:
2429 case DW_AT_decl_line:
2432 case DW_AT_decl_column:
2441 if (name && name[0] && enum_value) {
2442 m_ast.AddEnumerationValueToEnumerationType(
2443 clang_type, decl, name, *enum_value, enumerator_byte_size * 8);
2444 ++enumerators_added;
2447 return enumerators_added;
2452 bool is_variadic =
false;
2453 bool has_template_params =
false;
2454 std::vector<CompilerType> param_types;
2455 llvm::SmallVector<llvm::StringRef> param_names;
2462 clang::DeclContext *containing_decl_ctx =
2464 assert(containing_decl_ctx);
2466 const unsigned cv_quals =
2470 has_template_params, param_types, param_names);
2472 for (
size_t i = 0; i < param_types.size(); i++) {
2475 sstr << param_types[i].GetTypeName();
2480 if (cv_quals & clang::Qualifiers::Const)
2488 llvm::DWARFAddressRangesVector unused_func_ranges;
2489 const char *name =
nullptr;
2490 const char *mangled =
nullptr;
2491 std::optional<int> decl_file;
2492 std::optional<int> decl_line;
2493 std::optional<int> decl_column;
2494 std::optional<int> call_file;
2495 std::optional<int> call_line;
2496 std::optional<int> call_column;
2501 if (tag != DW_TAG_subprogram)
2505 decl_line, decl_column, call_file, call_line,
2506 call_column, &frame_base)) {
2508 if (mangled && name &&
2516 }
else if (mangled) {
2518 }
else if ((die.
GetParent().
Tag() == DW_TAG_compile_unit ||
2524 name && strcmp(name,
"main") != 0) {
2560 Address func_addr = func_ranges[0].GetBaseAddress();
2562 func_sp = std::make_shared<Function>(
2565 func_user_id, func_name, func_type, std::move(func_addr),
2566 std::move(func_ranges));
2568 if (func_sp.get() !=
nullptr) {
2570 func_sp->GetFrameBaseExpression() = frame_base;
2572 return func_sp.get();
2581struct PropertyAttributes {
2582 explicit PropertyAttributes(
const DWARFDIE &die);
2583 const char *prop_name =
nullptr;
2584 const char *prop_getter_name =
nullptr;
2585 const char *prop_setter_name =
nullptr;
2587 uint32_t prop_attributes = 0;
2590struct DiscriminantValue {
2591 explicit DiscriminantValue(
const DWARFDIE &die,
ModuleSP module_sp);
2593 uint32_t byte_offset;
2595 DWARFFormValue type_ref;
2598struct VariantMember {
2599 explicit VariantMember(DWARFDIE &die,
ModuleSP module_sp);
2600 bool IsDefault()
const;
2602 std::optional<llvm::APInt> discr_value;
2603 DWARFFormValue type_ref;
2604 ConstString variant_name;
2605 uint32_t byte_offset;
2610 explicit VariantPart(
const DWARFDIE &die,
const DWARFDIE &parent_die,
2613 std::vector<VariantMember> &members();
2615 DiscriminantValue &discriminant();
2618 std::vector<VariantMember> _members;
2619 DiscriminantValue _discriminant;
2624ConstString VariantMember::GetName()
const {
return this->variant_name; }
2626bool VariantMember::IsDefault()
const {
return !discr_value; }
2628VariantMember::VariantMember(DWARFDIE &die,
lldb::ModuleSP module_sp) {
2629 assert(die.
Tag() == llvm::dwarf::DW_TAG_variant);
2631 DWARFFormValue discr_form;
2632 die.
GetDIE()->GetAttributeValue(die.
GetCU(), DW_AT_discr_value, discr_form);
2639 if ((form == DW_FORM_block1 && discr_form.
Unsigned() == 16) ||
2640 form == DW_FORM_data16) {
2641 const uint8_t *block_data = discr_form.
BlockData();
2646 uint64_t lo = extractor.GetU64(&offset);
2647 uint64_t hi = extractor.GetU64(&offset);
2648 uint64_t words[] = {lo, hi};
2649 this->discr_value = llvm::APInt(128, words);
2653 this->discr_value = llvm::APInt(
sizeof(uint64_t) * 8, result.value());
2655 this->discr_value = std::nullopt;
2659 for (
auto child_die : die.
children()) {
2660 switch (child_die.Tag()) {
2661 case llvm::dwarf::DW_TAG_member: {
2662 DWARFAttributes attributes = child_die.GetAttributes();
2663 for (std::size_t i = 0; i < attributes.
Size(); ++i) {
2664 DWARFFormValue form_value;
2669 variant_name = ConstString(form_value.
AsCString());
2672 type_ref = form_value;
2675 case DW_AT_data_member_location:
2676 if (
auto maybe_offset =
2678 byte_offset = *maybe_offset;
2695DiscriminantValue::DiscriminantValue(
const DWARFDIE &die,
ModuleSP module_sp) {
2697 DWARFAttributes attributes = referenced_die.GetAttributes();
2698 for (std::size_t i = 0; i < attributes.
Size(); ++i) {
2700 DWARFFormValue form_value;
2704 type_ref = form_value;
2706 case DW_AT_data_member_location:
2707 if (
auto maybe_offset =
2709 byte_offset = *maybe_offset;
2718VariantPart::VariantPart(
const DWARFDIE &die,
const DWARFDIE &parent_die,
2720 : _members(), _discriminant(die, module_sp) {
2722 for (
auto child : die.
children()) {
2723 if (child.Tag() == llvm::dwarf::DW_TAG_variant) {
2724 _members.push_back(VariantMember(child, module_sp));
2729std::vector<VariantMember> &VariantPart::members() {
return this->_members; }
2731DiscriminantValue &VariantPart::discriminant() {
return this->_discriminant; }
2736 for (
size_t i = 0; i < attributes.
Size(); ++i) {
2747 case DW_AT_bit_offset:
2750 case DW_AT_bit_size:
2753 case DW_AT_byte_size:
2756 case DW_AT_const_value:
2759 case DW_AT_data_bit_offset:
2762 case DW_AT_data_member_location:
2763 if (
auto maybe_offset =
2768 case DW_AT_artificial:
2771 case DW_AT_declaration:
2798PropertyAttributes::PropertyAttributes(
const DWARFDIE &die) {
2801 for (
size_t i = 0; i < attributes.
Size(); ++i) {
2806 case DW_AT_APPLE_property_name:
2809 case DW_AT_APPLE_property_getter:
2810 prop_getter_name = form_value.
AsCString();
2812 case DW_AT_APPLE_property_setter:
2813 prop_setter_name = form_value.
AsCString();
2815 case DW_AT_APPLE_property_attribute:
2816 prop_attributes = form_value.
Unsigned();
2826 ConstString fixed_setter;
2830 if (prop_getter_name && prop_getter_name[0] ==
'-') {
2831 std::optional<const ObjCLanguage::ObjCMethodName> prop_getter_method =
2833 if (prop_getter_method)
2835 ConstString(prop_getter_method->GetSelector()).GetCString();
2838 if (prop_setter_name && prop_setter_name[0] ==
'-') {
2839 std::optional<const ObjCLanguage::ObjCMethodName> prop_setter_method =
2841 if (prop_setter_method)
2843 ConstString(prop_setter_method->GetSelector()).GetCString();
2847 if (!prop_getter_name)
2848 prop_getter_name = prop_name;
2849 if (!prop_setter_name && prop_name[0] &&
2850 !(prop_attributes & DW_APPLE_PROPERTY_readonly)) {
2853 ss.
Printf(
"set%c%s:", toupper(prop_name[0]), &prop_name[1]);
2856 prop_setter_name = fixed_setter.
GetCString();
2865 assert(die.
Tag() == DW_TAG_APPLE_property);
2870 const PropertyAttributes propAttrs(die);
2872 if (!propAttrs.prop_name) {
2873 module_sp->ReportError(
"{0:x8}: DW_TAG_APPLE_property has no name.",
2880 module_sp->ReportError(
2881 "{0:x8}: DW_TAG_APPLE_property '{1}' refers to type {2:x16}"
2882 " which was unable to be parsed",
2883 die.
GetID(), propAttrs.prop_name,
2890 delayed_properties.emplace_back(
2891 class_clang_type, propAttrs.prop_name,
2893 propAttrs.prop_getter_name, propAttrs.prop_attributes, metadata);
2899 assert(qt->isIntegralOrEnumerationType());
2902 return llvm::createStringError(llvm::inconvertibleErrorCode(),
2903 "TypeSystem not clang");
2907 const unsigned type_bits = ast.getIntWidth(qt);
2908 const bool is_unsigned = qt->isUnsignedIntegerType();
2912 constexpr std::size_t max_bit_size = 64;
2917 if (type_bits > max_bit_size) {
2918 auto msg = llvm::formatv(
"Can only parse integers with up to {0} bits, but "
2919 "given integer has {1} bits.",
2920 max_bit_size, type_bits);
2921 return llvm::createStringError(llvm::inconvertibleErrorCode(), msg.str());
2925 llvm::APInt result(max_bit_size, form_value.
Unsigned(), !is_unsigned);
2931 const unsigned required_bits =
2932 is_unsigned ? result.getActiveBits() : result.getSignificantBits();
2935 if (required_bits > type_bits) {
2936 std::string value_as_str = is_unsigned
2937 ? std::to_string(form_value.
Unsigned())
2938 : std::to_string(form_value.
Signed());
2939 auto msg = llvm::formatv(
"Can't store {0} value {1} in integer with {2} "
2941 (is_unsigned ?
"unsigned" :
"signed"),
2942 value_as_str, type_bits);
2943 return llvm::createStringError(llvm::inconvertibleErrorCode(), msg.str());
2947 if (result.getBitWidth() > type_bits)
2948 result = result.trunc(type_bits);
2956 assert(die.
Tag() == DW_TAG_member || die.
Tag() == DW_TAG_variable);
2967 LLDB_LOG(log,
"Failed to add variable to the record type");
2976 llvm::Expected<llvm::APInt> const_value_or_err =
2978 if (!const_value_or_err) {
2980 "Failed to add const value to variable {1}: {0}",
2981 v->getQualifiedNameAsString());
2994 assert(die.
Tag() == DW_TAG_member);
2999 const uint64_t parent_byte_size =
3001 const uint64_t parent_bit_size =
3026 module_sp->ReportError(
3027 "{0:x8}: DW_TAG_member '{1}' refers to type {2:x16}"
3028 " which was unable to be parsed",
3031 module_sp->ReportError(
"{0:x8}: DW_TAG_member refers to type {1:x16}"
3032 " which was unable to be parsed",
3038 const uint64_t character_width = 8;
3047 this_field_info.
bit_offset = field_bit_offset;
3055 byte_size = llvm::expectedToOptional(member_type->
GetByteSize(
nullptr));
3059 this_field_info.
bit_offset += byte_size.value_or(0) * 8;
3073 !(parent_die.
Tag() == DW_TAG_union_type &&
3075 ((this_field_info.
bit_offset >= parent_bit_size) ||
3081 "{0:x16}: {1} ({2}) bitfield named \"{3}\" has invalid "
3082 "bit offset ({4:x8}) member will be ignored. Please file a bug "
3084 "compiler and include the preprocessed output for {5}",
3091 field_bit_offset = this_field_info.
bit_offset;
3096 bool detect_unnamed_bitfields =
true;
3099 detect_unnamed_bitfields =
3102 if (detect_unnamed_bitfields)
3104 last_field_info, this_field_info);
3106 last_field_info = this_field_info;
3111 this_field_info.
bit_offset = field_bit_offset;
3115 if (std::optional<uint64_t> clang_type_size =
3116 llvm::expectedToOptional(member_type->
GetByteSize(
nullptr))) {
3117 this_field_info.
bit_size = *clang_type_size * character_width;
3124 last_field_info = this_field_info;
3144 class_clang_type, attrs.
name, member_clang_type, attrs.
bit_size);
3146 m_ast.SetMetadataAsUserID(field_decl, die.
GetID());
3149 std::make_pair(field_decl, field_bit_offset));
3154 std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
3155 std::vector<DWARFDIE> &member_function_dies,
3156 std::vector<DWARFDIE> &contained_type_dies,
3173 case DW_TAG_APPLE_property:
3177 case DW_TAG_variant_part:
3183 case DW_TAG_variable: {
3192 case DW_TAG_subprogram:
3194 member_function_dies.push_back(die);
3197 case DW_TAG_inheritance:
3199 base_classes, layout_info);
3203 if (llvm::dwarf::isType(tag))
3204 contained_type_dies.push_back(die);
3213 clang::DeclContext *containing_decl_ctx,
const DWARFDIE &parent_die,
3214 bool &is_variadic,
bool &has_template_params,
3215 std::vector<CompilerType> &function_param_types,
3223 case DW_TAG_formal_parameter: {
3233 function_param_names.emplace_back(die.
GetName());
3237 case DW_TAG_unspecified_parameters:
3241 case DW_TAG_template_type_parameter:
3242 case DW_TAG_template_value_parameter:
3243 case DW_TAG_GNU_template_parameter_pack:
3249 has_template_params =
true;
3257 assert(function_param_names.size() == function_param_types.size());
3264 switch (die.
Tag()) {
3265 case DW_TAG_constant:
3266 case DW_TAG_formal_parameter:
3267 case DW_TAG_imported_declaration:
3268 case DW_TAG_imported_module:
3270 case DW_TAG_variable:
3284 return cache_pos->second;
3299 clang::Decl *decl =
nullptr;
3300 switch (die.
Tag()) {
3301 case DW_TAG_variable:
3302 case DW_TAG_constant:
3303 case DW_TAG_formal_parameter: {
3306 if (
dwarf && type) {
3307 const char *name = die.
GetName();
3308 clang::DeclContext *decl_context =
3310 dwarf->GetDeclContextContainingUID(die.
GetID()));
3311 decl =
m_ast.CreateVariableDeclaration(
3317 case DW_TAG_imported_declaration: {
3322 if (imported_decl) {
3323 clang::DeclContext *decl_context =
3325 dwarf->GetDeclContextContainingUID(die.
GetID()));
3326 if (clang::NamedDecl *clang_imported_decl =
3327 llvm::dyn_cast<clang::NamedDecl>(
3329 decl =
m_ast.CreateUsingDeclaration(
3335 case DW_TAG_imported_module: {
3342 if (imported_decl_ctx) {
3343 clang::DeclContext *decl_context =
3345 dwarf->GetDeclContextContainingUID(die.
GetID()));
3346 if (clang::NamespaceDecl *ns_decl =
3349 decl =
m_ast.CreateUsingDirectiveDeclaration(
3371 bool try_parsing_type =
true;
3372 switch (die.
Tag()) {
3373 case DW_TAG_compile_unit:
3374 case DW_TAG_partial_unit:
3375 decl_ctx =
m_ast.GetTranslationUnitDecl();
3376 try_parsing_type =
false;
3379 case DW_TAG_namespace:
3381 try_parsing_type =
false;
3384 case DW_TAG_imported_declaration:
3386 try_parsing_type =
false;
3389 case DW_TAG_lexical_block:
3391 try_parsing_type =
false;
3398 if (decl_ctx ==
nullptr && try_parsing_type) {
3418 parent = parent.GetParent()) {
3420 if (tag == DW_TAG_module) {
3440 switch (die.
Tag()) {
3441 case DW_TAG_subprogram:
3442 case DW_TAG_inlined_subroutine:
3452 if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) {
3459 assert(0 &&
"Shouldn't call GetContainingFunctionWithAbstractOrigin on "
3460 "something not in a function");
3466 if (candidate.GetReferencedDIE(DW_AT_abstract_origin)) {
3488 assert(die.
Tag() == DW_TAG_lexical_block);
3489 DWARFDIE containing_function_with_abstract_origin =
3491 if (!containing_function_with_abstract_origin) {
3495 die, containing_function_with_abstract_origin);
3502 if (die && die.
Tag() == DW_TAG_lexical_block) {
3503 clang::BlockDecl *decl =
3508 clang::DeclContext *decl_context =
3522clang::NamespaceDecl *
3524 if (die && die.
Tag() == DW_TAG_namespace) {
3527 clang::NamespaceDecl *namespace_decl =
3530 return namespace_decl;
3532 const char *namespace_name = die.
GetName();
3533 clang::DeclContext *containing_decl_ctx =
3538 namespace_decl =
m_ast.GetUniqueNamespaceDeclaration(
3544 return namespace_decl;
3550clang::NamespaceDecl *
3552 assert(die && die.
Tag() == DW_TAG_imported_declaration);
3558 return static_cast<clang::NamespaceDecl *
>(it->getSecond());
3560 clang::NamespaceDecl *namespace_decl =
nullptr;
3567 switch (imported_uid.
Tag()) {
3568 case DW_TAG_imported_declaration:
3571 case DW_TAG_namespace:
3578 if (!namespace_decl)
3583 return namespace_decl;
3590 DWARFDIE decl_ctx_die =
dwarf->GetDeclContextDIEContainingDIE(die);
3592 if (decl_ctx_die_copy)
3593 *decl_ctx_die_copy = decl_ctx_die;
3596 clang::DeclContext *clang_decl_ctx =
3599 return clang_decl_ctx;
3601 return m_ast.GetTranslationUnitDecl();
3625 if (!class_type || !src_class_die || !dst_class_die)
3627 if (src_class_die.
Tag() != dst_class_die.
Tag())
3637 if (die.
Tag() != DW_TAG_subprogram)
3649 map_artificial.Append(const_name, die);
3651 map.Append(const_name, die);
3660 src_die = src_die.GetSibling()) {
3661 gather(src_die, src_name_to_die, src_name_to_die_artificial);
3664 dst_die = dst_die.GetSibling()) {
3665 gather(dst_die, dst_name_to_die, dst_name_to_die_artificial);
3667 const uint32_t src_size = src_name_to_die.
GetSize();
3668 const uint32_t dst_size = dst_name_to_die.
GetSize();
3671 bool fast_path =
true;
3673 if (src_size != dst_size)
3679 for (idx = 0; idx < src_size; ++idx) {
3683 if (src_die.
Tag() != dst_die.
Tag())
3690 if (src_name == dst_name || (strcmp(src_name, dst_name) == 0))
3697 auto *src_dwarf_ast_parser = llvm::cast<DWARFASTParserClang>(
3699 auto *dst_dwarf_ast_parser = llvm::cast<DWARFASTParserClang>(
3703 clang::DeclContext *dst_decl_ctx =
3704 dst_dwarf_ast_parser->m_die_to_decl_ctx[dst.GetDIE()];
3706 src_dwarf_ast_parser->LinkDeclContextToDIE(dst_decl_ctx, src);
3708 if (
Type *src_child_type = die_to_type.lookup(src.
GetDIE()))
3709 die_to_type[dst.GetDIE()] = src_child_type;
3716 for (idx = 0; idx < src_size; ++idx) {
3726 src_name_to_die.
Sort();
3728 for (idx = 0; idx < dst_size; ++idx) {
3733 if (src_die && (src_die.
Tag() == dst_die.
Tag()))
3734 link(src_die, dst_die);
3736 failures.push_back(dst_die);
3741 const uint32_t src_size_artificial = src_name_to_die_artificial.
GetSize();
3742 const uint32_t dst_size_artificial = dst_name_to_die_artificial.
GetSize();
3744 if (src_size_artificial && dst_size_artificial) {
3745 dst_name_to_die_artificial.
Sort();
3747 for (idx = 0; idx < src_size_artificial; ++idx) {
3753 dst_name_to_die_artificial.
Find(src_name_artificial,
DWARFDIE());
3757 link(src_die, dst_die);
3761 if (dst_size_artificial) {
3762 for (idx = 0; idx < dst_size_artificial; ++idx) {
3768 return !failures.empty();
3772 FieldInfo const &last_field_info, uint64_t last_field_end,
3777 if (this_field_info.
bit_offset <= last_field_end)
3791 const bool have_base = layout_info.
base_offsets.size() != 0;
3792 const bool this_is_first_field =
3794 const bool first_field_is_vptr =
3797 if (have_base && (this_is_first_field || first_field_is_vptr))
3808 const uint64_t word_width = 32;
3816 if (last_field_end != 0 && ((last_field_end % word_width) != 0))
3817 last_field_end += word_width - (last_field_end % word_width);
3822 current_field, class_layout_info))
3827 const uint64_t unnamed_bit_size = current_field.
bit_offset - last_field_end;
3828 const uint64_t unnamed_bit_offset = last_field_end;
3830 clang::FieldDecl *unnamed_bitfield_decl =
3832 class_clang_type, llvm::StringRef(),
3837 std::make_pair(unnamed_bitfield_decl, unnamed_bit_offset));
3844 assert(die.
Tag() == llvm::dwarf::DW_TAG_variant_part);
3850 VariantPart variants(die, parent_die, module_sp);
3852 auto discriminant_type =
3853 die.
ResolveTypeUID(variants.discriminant().type_ref.Reference());
3855 auto decl_context =
m_ast.GetDeclContextForType(class_clang_type);
3857 auto inner_holder =
m_ast.CreateRecordType(
3860 llvm::formatv(
"{0}$Inner", class_clang_type.
GetTypeName(
false))),
3862 m_ast.StartTagDeclarationDefinition(inner_holder);
3863 m_ast.SetIsPacked(inner_holder);
3865 for (
auto member : variants.members()) {
3867 auto has_discriminant = !member.IsDefault();
3869 auto member_type = die.
ResolveTypeUID(member.type_ref.Reference());
3871 auto field_type =
m_ast.CreateRecordType(
3873 std::string(llvm::formatv(
"{0}$Variant", member.GetName())),
3874 llvm::to_underlying(clang::TagTypeKind::Struct),
3877 m_ast.StartTagDeclarationDefinition(field_type);
3878 auto offset = member.byte_offset;
3880 if (has_discriminant) {
3881 m_ast.AddFieldToRecordType(field_type,
"$discr$",
3882 discriminant_type->GetFullCompilerType(),
3883 variants.discriminant().byte_offset);
3885 llvm::expectedToOptional(discriminant_type->GetByteSize(
nullptr))
3889 m_ast.AddFieldToRecordType(field_type,
"value",
3890 member_type->GetFullCompilerType(), offset * 8);
3892 m_ast.CompleteTagDeclarationDefinition(field_type);
3894 auto name = std::string(
"$variant$");
3895 if (has_discriminant) {
3898 llvm::SmallString<40> discr_str;
3899 member.discr_value.value().toStringUnsigned(discr_str);
3900 name.append(discr_str.c_str());
3903 auto variant_decl =
m_ast.AddFieldToRecordType(
3904 inner_holder, llvm::StringRef(name), field_type, 0);
3909 auto inner_field =
m_ast.AddFieldToRecordType(
3910 class_clang_type, llvm::StringRef(
"$variants$"), inner_holder, 0);
3912 m_ast.CompleteTagDeclarationDefinition(inner_holder);
static bool DeclKindIsCXXClass(clang::Decl::Kind decl_kind)
static std::string GetUnitName(const DWARFDIE &die)
static std::string MakeLLDBFuncAsmLabel(const DWARFDIE &die)
static unsigned GetCXXMethodCVQuals(const DWARFDIE &subprogram, const DWARFDIE &object_parameter)
In order to determine the CV-qualifiers for a C++ class method in DWARF, we have to look at the CV-qu...
static clang::CallingConv ConvertDWARFCallingConventionToClang(const ParsedDWARFTypeAttributes &attrs)
static bool IsSubroutine(const DWARFDIE &die)
static AccessType GetDefaultAccessibility(const DWARFDIE &die)
static TypePayloadClang GetPtrAuthMofidierPayload(const DWARFDIE &die)
static std::optional< clang::APValue > MakeAPValue(const clang::ASTContext &ast, CompilerType clang_type, uint64_t value)
static bool TagIsRecordType(dw_tag_t tag)
Returns true for C++ constructs represented by clang::CXXRecordDecl.
static lldb::ModuleSP GetContainingClangModule(const DWARFDIE &die)
static void ApplyObjCRuntimeName(const DWARFDIE &die, CompilerType type)
The ASTImporter copies attributes only when a decl is first imported, so this must run before the dec...
static DWARFDIE FindFirstChildWithAbstractOrigin(const DWARFDIE &block, const DWARFDIE &function)
static DWARFDIE FindAnyChildWithAbstractOrigin(const DWARFDIE &context)
static bool IsClangModuleFwdDecl(const DWARFDIE &Die)
Detect a forward declaration that is nested in a DW_TAG_module.
static DWARFDIE GetContainingClangModuleDIE(const DWARFDIE &die)
static DWARFDIE GetContainingFunctionWithAbstractOrigin(const DWARFDIE &die)
static void PrepareContextToReceiveMembers(TypeSystemClang &ast, ClangASTImporter &ast_importer, clang::DeclContext *decl_ctx, DWARFDIE die, const char *type_name_cstr)
This function ensures we are able to add members (nested types, functions, etc.) to this type.
static std::optional< uint32_t > ExtractDataMemberLocation(DWARFDIE const &die, DWARFFormValue const &form_value, ModuleSP module_sp)
static bool ShouldIgnoreArtificialField(llvm::StringRef FieldName)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
#define LLDB_LOG_ERROR(log, error,...)
#define DIE_IS_BEING_PARSED
static llvm::StringRef GetName(XcodeSDK::Type type)
const char * m_property_getter_name
CompilerType m_class_opaque_type
CompilerType m_property_opaque_type
const char * m_property_setter_name
uint32_t m_property_attributes
DelayedAddObjCClassProperty(const CompilerType &class_opaque_type, const char *property_name, const CompilerType &property_opaque_type, const char *property_setter_name, const char *property_getter_name, uint32_t property_attributes, ClangASTMetadata metadata)
ClangASTMetadata m_metadata
const char * m_property_name
lldb::TypeSP ParsePointerToMemberType(const lldb_private::plugin::dwarf::DWARFDIE &die, const ParsedDWARFTypeAttributes &attrs)
bool CompleteEnumType(const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::Type *type, const lldb_private::CompilerType &clang_type)
clang::NamespaceDecl * ResolveImportedDeclarationDIE(const lldb_private::plugin::dwarf::DWARFDIE &die)
Returns the namespace decl that a DW_TAG_imported_declaration imports.
void CreateStaticMemberVariable(const lldb_private::plugin::dwarf::DWARFDIE &die, const MemberAttributes &attrs, const lldb_private::CompilerType &class_clang_type)
If the specified 'die' represents a static data member, creates a 'clang::VarDecl' for it and attache...
std::unique_ptr< lldb_private::ClangASTImporter > m_clang_ast_importer_up
lldb::TypeSP ParseEnum(const lldb_private::SymbolContext &sc, const lldb_private::plugin::dwarf::DWARFDIE &die, ParsedDWARFTypeAttributes &attrs)
std::string GetDIEClassTemplateParams(lldb_private::plugin::dwarf::DWARFDIE die) override
Returns the template parameters of a class DWARFDIE as a string.
bool CompleteRecordType(const lldb_private::plugin::dwarf::DWARFDIE &die, const lldb_private::CompilerType &clang_type)
lldb::TypeSP UpdateSymbolContextScopeForType(const lldb_private::SymbolContext &sc, const lldb_private::plugin::dwarf::DWARFDIE &die, lldb::TypeSP type_sp)
If type_sp is valid, calculate and set its symbol context scope, and update the type list for its bac...
lldb_private::TypeSystemClang & m_ast
bool ShouldCreateUnnamedBitfield(FieldInfo const &last_field_info, uint64_t last_field_end, FieldInfo const &this_field_info, lldb_private::ClangASTImporter::LayoutInfo const &layout_info) const
Returns 'true' if we should create an unnamed bitfield and add it to the parser's current AST.
bool CompleteTypeFromDWARF(const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::Type *type, const lldb_private::CompilerType &compiler_type) override
lldb::TypeSP ParseArrayType(const lldb_private::plugin::dwarf::DWARFDIE &die, const ParsedDWARFTypeAttributes &attrs)
lldb_private::ClangASTImporter & GetClangASTImporter()
clang::BlockDecl * ResolveBlockDIE(const lldb_private::plugin::dwarf::DWARFDIE &die)
lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, const lldb_private::plugin::dwarf::DWARFDIE &die, bool *type_is_new_ptr) override
clang::DeclContext * GetClangDeclContextContainingDIE(const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::plugin::dwarf::DWARFDIE *decl_ctx_die)
lldb_private::plugin::dwarf::DWARFDIE GetObjectParameter(const lldb_private::plugin::dwarf::DWARFDIE &subprogram, const lldb_private::plugin::dwarf::DWARFDIE &decl_ctx_die)
Get the object parameter DIE if one exists, otherwise returns a default DWARFDIE.
clang::DeclContext * GetDeclContextForBlock(const lldb_private::plugin::dwarf::DWARFDIE &die)
lldb::TypeSP ParseTypeModifier(const lldb_private::SymbolContext &sc, const lldb_private::plugin::dwarf::DWARFDIE &die, ParsedDWARFTypeAttributes &attrs)
lldb::TypeSP ParseTypeFromClangModule(const lldb_private::SymbolContext &sc, const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::Log *log)
Follow Clang Module Skeleton CU references to find a type definition.
lldb::TypeSP ParseStructureLikeDIE(const lldb_private::SymbolContext &sc, const lldb_private::plugin::dwarf::DWARFDIE &die, const ParsedDWARFTypeAttributes &attrs)
Parse a structure, class, or union type DIE.
DIEToDeclContextMap m_die_to_decl_ctx
void ParseObjCProperty(const lldb_private::plugin::dwarf::DWARFDIE &die, const lldb_private::plugin::dwarf::DWARFDIE &parent_die, const lldb_private::CompilerType &class_clang_type, DelayedPropertyList &delayed_properties)
Parses a DW_TAG_APPLE_property DIE and appends the parsed data to the list of delayed Objective-C pro...
void EnsureAllDIEsInDeclContextHaveBeenParsed(lldb_private::CompilerDeclContext decl_context) override
clang::NamespaceDecl * ResolveNamespaceDIE(const lldb_private::plugin::dwarf::DWARFDIE &die)
void GetUniqueTypeNameAndDeclaration(const lldb_private::plugin::dwarf::DWARFDIE &die, lldb::LanguageType language, lldb_private::ConstString &unique_typename, lldb_private::Declaration &decl_declaration)
lldb_private::ConstString ConstructDemangledNameFromDWARF(const lldb_private::plugin::dwarf::DWARFDIE &die) override
lldb_private::CompilerDeclContext GetDeclContextContainingUIDFromDWARF(const lldb_private::plugin::dwarf::DWARFDIE &die) override
DIEToDeclMap m_die_to_decl
void ParseInheritance(const lldb_private::plugin::dwarf::DWARFDIE &die, const lldb_private::plugin::dwarf::DWARFDIE &parent_die, const lldb_private::CompilerType class_clang_type, const lldb::ModuleSP &module_sp, std::vector< std::unique_ptr< clang::CXXBaseSpecifier > > &base_classes, lldb_private::ClangASTImporter::LayoutInfo &layout_info)
Parses a DW_TAG_inheritance DIE into a base/super class.
void ParseSingleMember(const lldb_private::plugin::dwarf::DWARFDIE &die, const lldb_private::plugin::dwarf::DWARFDIE &parent_die, const lldb_private::CompilerType &class_clang_type, lldb_private::ClangASTImporter::LayoutInfo &layout_info, FieldInfo &last_field_info)
size_t ParseChildEnumerators(const lldb_private::CompilerType &compiler_type, bool is_signed, uint32_t enumerator_byte_size, const lldb_private::plugin::dwarf::DWARFDIE &parent_die)
bool ParseObjCMethod(const lldb_private::ObjCLanguage::ObjCMethodName &objc_method, const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::CompilerType clang_type, const ParsedDWARFTypeAttributes &attrs, bool is_variadic)
Helper function called by ParseSubroutine when parsing ObjC-methods.
~DWARFASTParserClang() override
std::vector< DelayedAddObjCClassProperty > DelayedPropertyList
bool CopyUniqueClassMethodTypes(const lldb_private::plugin::dwarf::DWARFDIE &src_class_die, const lldb_private::plugin::dwarf::DWARFDIE &dst_class_die, lldb_private::Type *class_type, std::vector< lldb_private::plugin::dwarf::DWARFDIE > &failures)
clang::DeclContext * GetClangDeclContextForDIE(const lldb_private::plugin::dwarf::DWARFDIE &die)
bool ParseTemplateDIE(const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::TypeSystemClang::TemplateParameterInfos &template_param_infos)
lldb_private::CompilerDeclContext GetDeclContextForUIDFromDWARF(const lldb_private::plugin::dwarf::DWARFDIE &die) override
llvm::Expected< llvm::APInt > ExtractIntFromFormValue(const lldb_private::CompilerType &int_type, const lldb_private::plugin::dwarf::DWARFFormValue &form_value) const
Extracts an value for a given Clang integer type from a DWARFFormValue.
bool ParseChildMembers(const lldb_private::plugin::dwarf::DWARFDIE &die, const lldb_private::CompilerType &class_compiler_type, std::vector< std::unique_ptr< clang::CXXBaseSpecifier > > &base_classes, std::vector< lldb_private::plugin::dwarf::DWARFDIE > &member_function_dies, std::vector< lldb_private::plugin::dwarf::DWARFDIE > &contained_type_dies, DelayedPropertyList &delayed_properties, lldb_private::ClangASTImporter::LayoutInfo &layout_info)
clang::DeclContext * GetCachedClangDeclContextForDIE(const lldb_private::plugin::dwarf::DWARFDIE &die)
DIEToModuleMap m_die_to_module
DeclContextToDIEMap m_decl_ctx_to_die
lldb_private::Function * ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit, const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::AddressRanges func_ranges) override
void ParseChildParameters(clang::DeclContext *containing_decl_ctx, const lldb_private::plugin::dwarf::DWARFDIE &parent_die, bool &is_variadic, bool &has_template_params, std::vector< lldb_private::CompilerType > &function_param_types, llvm::SmallVectorImpl< llvm::StringRef > &function_param_names)
void AddUnnamedBitfieldToRecordTypeIfNeeded(lldb_private::ClangASTImporter::LayoutInfo &class_layout_info, const lldb_private::CompilerType &class_clang_type, const FieldInfo &previous_field, const FieldInfo ¤t_field)
Tries to detect whether class_clang_type contained an unnamed bit-field between previous_field and cu...
lldb::TypeSP ParseSubroutine(const lldb_private::plugin::dwarf::DWARFDIE &die, const ParsedDWARFTypeAttributes &attrs)
void MapDeclDIEToDefDIE(const lldb_private::plugin::dwarf::DWARFDIE &decl_die, const lldb_private::plugin::dwarf::DWARFDIE &def_die)
lldb_private::CompilerDecl GetDeclForUIDFromDWARF(const lldb_private::plugin::dwarf::DWARFDIE &die) override
bool ParseTemplateParameterInfos(const lldb_private::plugin::dwarf::DWARFDIE &parent_die, lldb_private::TypeSystemClang::TemplateParameterInfos &template_param_infos)
DWARFASTParserClang(lldb_private::TypeSystemClang &ast)
void ParseRustVariantPart(lldb_private::plugin::dwarf::DWARFDIE &die, const lldb_private::plugin::dwarf::DWARFDIE &parent_die, const lldb_private::CompilerType &class_clang_type, lldb_private::ClangASTImporter::LayoutInfo &layout_info)
Parses DW_TAG_variant_part DIE into a structure that encodes all variants Note that this is currently...
clang::Decl * GetClangDeclForDIE(const lldb_private::plugin::dwarf::DWARFDIE &die)
void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, const lldb_private::plugin::dwarf::DWARFDIE &die)
lldb_private::OptionalClangModuleID GetOwningClangModule(const lldb_private::plugin::dwarf::DWARFDIE &die)
std::pair< bool, lldb::TypeSP > ParseCXXMethod(const lldb_private::plugin::dwarf::DWARFDIE &die, lldb_private::CompilerType clang_type, const ParsedDWARFTypeAttributes &attrs, const lldb_private::plugin::dwarf::DWARFDIE &decl_ctx_die, const lldb_private::plugin::dwarf::DWARFDIE &object_parameter, bool &ignore_containing_context)
Helper function called by ParseSubroutine when parsing C++ methods.
A section + offset based address class.
Block * FindBlockByID(lldb::user_id_t block_id)
Manages and observes all Clang AST node importing in LLDB.
CompilerType CopyType(TypeSystemClang &dst, const CompilerType &src_type)
Copies the given type and the respective declarations to the destination type system.
bool CanImport(const CompilerType &type)
Returns true iff the given type was copied from another TypeSystemClang and the original type in this...
void SetRecordLayout(clang::RecordDecl *decl, const LayoutInfo &layout)
Sets the layout for the given RecordDecl.
bool RequireCompleteType(clang::QualType type)
A class that describes a compilation unit.
void AddFunction(lldb::FunctionSP &function_sp)
Add a function to this compile unit.
Represents a generic declaration context in a program.
void * GetOpaqueDeclContext() const
Represents a generic declaration such as a function declaration.
void * GetOpaqueDecl() const
Generic representation of a type in a programming language.
bool IsEnumerationType(bool &is_signed) const
TypeSystemSPWrapper GetTypeSystem() const
Accessors.
bool IsCompleteType() const
llvm::Expected< uint64_t > GetByteSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bytes.
lldb::opaque_compiler_type_t GetOpaqueQualType() const
bool IsBeingDefined() const
bool IsIntegerOrEnumerationType(bool &is_signed) const
ConstString GetTypeName(bool BaseOnly=false) const
bool IsEnumerationIntegerTypeSigned() const
bool GetCompleteType() const
Type Completion.
bool IsRealFloatingPointType() const
Returns true for non-complex float types.
llvm::Expected< uint64_t > GetBitSize(ExecutionContextScope *exe_scope) const
Return the size of the type in bits.
A uniqued constant string class.
bool IsEmpty() const
Test for empty string.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
void SetString(llvm::StringRef s)
const char * GetCString() const
Get the string value as a C string.
const char * AsCString(const char *value_if_empty) const
Get the string value as a C string.
"lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file address range to a single ...
bool IsValid() const
Return true if the location expression contains data.
static llvm::Expected< Value > Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx, lldb::ModuleSP module_sp, const DataExtractor &opcodes, const Delegate *dwarf_cu, const lldb::RegisterKind reg_set, const Value *initial_value_ptr, const Value *object_address_ptr)
Evaluate a DWARF location expression in a particular context.
A class that describes the declaration location of a lldb object.
void SetLine(uint32_t line)
Set accessor for the declaration line number.
void SetColumn(uint16_t column)
Set accessor for the declaration column number.
void Clear()
Clear the object's state.
void SetFile(const FileSpec &file_spec)
Set accessor for the declaration file specification.
A class that describes a function.
Block & GetBlock(bool can_create)
Get accessor for the block list.
static bool LanguageIsCPlusPlus(lldb::LanguageType language)
static bool LanguageIsObjC(lldb::LanguageType language)
A class that handles mangled names.
void SetDemangledName(ConstString name)
void SetMangledName(ConstString name)
void SetValue(ConstString name)
Set the string value in this object.
static Mangled::ManglingScheme GetManglingScheme(llvm::StringRef name)
Try to identify the mangling scheme used.
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
A class that describes an executable image and its associated object and symbol files.
static std::optional< const ObjCMethodName > Create(llvm::StringRef name, bool strict)
The static factory method for creating a ObjCMethodName.
llvm::StringRef GetClassName() const
Returns a reference to the class name.
A plug-in interface definition class for object file parsers.
virtual lldb::ByteOrder GetByteOrder() const =0
Gets whether endian swapping should occur when extracting data from this object file.
llvm::StringRef GetString() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
"lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is part of a symbol context and c...
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
lldb::ModuleSP module_sp
The Module for a given query.
CompileUnit * comp_unit
The CompileUnit for a given query.
ObjectFile * GetObjectFile() override
Provides public interface for all SymbolFiles.
lldb::TypeSP FirstType() const
The implementation of lldb::Type's m_payload field for TypeSystemClang.
A class that contains all state required for type lookups.
void AddLanguage(lldb::LanguageType language)
Add a language family to the list of languages that should produce a match.
This class tracks the state and results of a TypeQuery.
bool AlreadySearched(lldb_private::SymbolFile *sym_file)
Check if a SymbolFile object has already been searched by this type match object.
llvm::DenseSet< lldb_private::SymbolFile * > & GetSearchedSymbolFiles()
Access the set of searched symbol files.
void SetPackName(char const *name)
void SetParameterPack(std::unique_ptr< TemplateParameterInfos > args)
void InsertArg(char const *name, clang::TemplateArgument arg)
bool hasParameterPack() const
TemplateParameterInfos const & GetParameterPack() const
A TypeSystem implementation based on Clang.
static clang::ObjCInterfaceDecl * GetAsObjCInterfaceDecl(const CompilerType &type)
bool SetDeclIsForcefullyCompleted(const clang::TagDecl *td)
static clang::DeclContext * GetDeclContextForType(clang::QualType type)
static bool IsCXXClassType(const CompilerType &type)
static clang::TagDecl * GetAsTagDecl(const CompilerType &type)
static void SetIntegerInitializerForVariable(clang::VarDecl *var, const llvm::APInt &init_value)
Initializes a variable with an integer value.
static clang::VarDecl * AddVariableToRecordType(const CompilerType &type, llvm::StringRef name, const CompilerType &var_type)
static void BuildIndirectFields(const CompilerType &type)
static bool CompleteTagDeclarationDefinition(const CompilerType &type)
static bool AddObjCClassProperty(const CompilerType &type, const char *property_name, const CompilerType &property_compiler_type, clang::ObjCIvarDecl *ivar_decl, const char *property_setter_name, const char *property_getter_name, uint32_t property_attributes, ClangASTMetadata metadata)
static clang::NamespaceDecl * DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc)
CompilerType GetTypeForDecl(clang::NamedDecl *decl)
static clang::DeclContext * DeclContextGetAsDeclContext(const CompilerDeclContext &dc)
static bool StartTagDeclarationDefinition(const CompilerType &type)
static clang::FieldDecl * AddFieldToRecordType(const CompilerType &type, llvm::StringRef name, const CompilerType &field_type, uint32_t bitfield_bit_size)
static bool IsObjCObjectOrInterfaceType(const CompilerType &type)
static void RequireCompleteType(CompilerType type)
Complete a type from debug info, or mark it as forcefully completed if there is no definition of the ...
clang::ASTContext & getASTContext() const
Returns the clang::ASTContext instance managed by this TypeSystemClang.
static CompilerType CreateMemberPointerType(const CompilerType &type, const CompilerType &pointee_type)
CompilerType GetForwardCompilerType()
uint32_t GetEncodingMask()
@ eEncodingIsRestrictUID
This type is the type whose UID is m_encoding_uid with the restrict qualifier added.
@ eEncodingIsConstUID
This type is the type whose UID is m_encoding_uid with the const qualifier added.
@ eEncodingIsVolatileUID
This type is the type whose UID is m_encoding_uid with the volatile qualifier added.
@ eEncodingIsAtomicUID
This type is the type whose UID is m_encoding_uid as an atomic type.
@ eEncodingIsLLVMPtrAuthUID
This type is a signed pointer.
@ eEncodingInvalid
Invalid encoding.
@ eEncodingIsTypedefUID
This type is alias to a type whose UID is m_encoding_uid.
@ eEncodingIsPointerUID
This type is pointer to a type whose UID is m_encoding_uid.
@ eEncodingIsLValueReferenceUID
This type is L value reference to a type whose UID is m_encoding_uid.
@ eEncodingIsRValueReferenceUID
This type is R value reference to a type whose UID is m_encoding_uid.
@ eEncodingIsUID
This type is the type whose UID is m_encoding_uid.
CompilerType GetLayoutCompilerType()
CompilerType GetFullCompilerType()
llvm::Expected< uint64_t > GetByteSize(ExecutionContextScope *exe_scope)
ConstString GetCStringAtIndex(uint32_t idx) const
T GetValueAtIndexUnchecked(uint32_t idx) const
T Find(ConstString unique_cstr, T fail_value) const
lldb_private::Type * GetTypeForDIE(const DWARFDIE &die)
DWARFASTParser(Kind kind)
static lldb::AccessType GetAccessTypeFromDWARF(uint32_t dwarf_accessibility)
static std::optional< SymbolFile::ArrayInfo > ParseChildArrayInfo(const DWARFDIE &parent_die, const ExecutionContext *exe_ctx=nullptr)
static DWARFDIE GetAnnotation(const DWARFDIE &die, llvm::StringRef name)
DWARFUnit * CompileUnitAtIndex(uint32_t i) const
dw_attr_t AttributeAtIndex(uint32_t i) const
bool ExtractFormValueAtIndex(uint32_t i, DWARFFormValue &form_value) const
DWARFAttributes GetAttributes(Recurse recurse=Recurse::yes) const
std::optional< uint64_t > GetAttributeValueAsOptionalUnsigned(const dw_attr_t attr) const
const DWARFDataExtractor & GetData() const
const char * GetAttributeValueAsString(const dw_attr_t attr, const char *fail_value) const
std::optional< DIERef > GetDIERef() const
SymbolFileDWARF * GetDWARF() const
DWARFUnit * GetCU() const
uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr, uint64_t fail_value) const
dw_offset_t GetOffset() const
lldb::user_id_t GetID() const
void GetName(Stream &s) const
const char * GetMangledName(bool substitute_name_allowed=true) const
DWARFDIE GetFirstChild() const
DWARFDIE GetParent() const
bool GetDIENamesAndRanges(const char *&name, const char *&mangled, llvm::DWARFAddressRangesVector &ranges, std::optional< int > &decl_file, std::optional< int > &decl_line, std::optional< int > &decl_column, std::optional< int > &call_file, std::optional< int > &call_line, std::optional< int > &call_column, DWARFExpressionList *frame_base) const
DWARFDIE GetDIE(dw_offset_t die_offset) const
llvm::iterator_range< child_iterator > children() const
The range of all the children of this DIE.
DWARFDIE GetParentDeclContextDIE() const
bool IsStructUnionOrClass() const
Type * ResolveTypeUID(const DWARFDIE &die) const
std::vector< CompilerContext > GetDeclContext(bool derive_template_names=false) const
Return this DIE's decl context as it is needed to look up types in Clang modules.
DWARFDIE GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const
DWARFDeclContext GetDWARFDeclContext() const
DWARFDIE GetReferencedDIE(const dw_attr_t attr) const
Type * ResolveType() const
const char * GetQualifiedName() const
SymbolFileDWARF & GetSymbolFileDWARF() const
uint8_t GetAddressByteSize() const override
bool Supports_unnamed_objc_bitfields()
uint64_t GetDWARFLanguageType()
lldb::ByteOrder GetByteOrder() const
FileSpec GetFile(size_t file_idx)
lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(const DWARFDIE &die, ConstString type_name, bool must_be_implementation)
DWARFDIE FindDefinitionDIE(const DWARFDIE &die)
lldb::ModuleSP GetExternalModule(ConstString name)
static DWARFASTParser * GetDWARFParser(DWARFUnit &unit)
static lldb::LanguageType GetLanguageFamily(DWARFUnit &unit)
Same as GetLanguage() but reports all C++ versions as C++ (no version).
Type * ResolveType(const DWARFDIE &die, bool assert_not_being_parsed=true, bool resolve_function_context=false)
virtual llvm::DenseMap< const DWARFDebugInfoEntry *, Type * > & GetDIEToType()
static CompilerDecl GetDecl(const DWARFDIE &die)
static lldb::LanguageType GetLanguage(DWARFUnit &unit)
static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die)
static CompilerDeclContext GetDeclContext(const DWARFDIE &die)
llvm::dwarf::Tag dw_tag_t
llvm::dwarf::Attribute dw_attr_t
llvm::dwarf::Form dw_form_t
llvm::StringRef DW_TAG_value_to_name(dw_tag_t tag)
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::Function > FunctionSP
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
@ eLanguageTypeObjC_plus_plus
Objective-C++.
@ eLanguageTypeObjC
Objective-C.
std::shared_ptr< lldb_private::Type > TypeSP
@ eEncodingSint
signed integer
std::shared_ptr< lldb_private::Module > ModuleSP
@ eRegisterKindDWARF
the register numbers seen DWARF
void SetIsArtificial(bool flag)
uint64_t GetEffectiveFieldEnd() const
If this field was folded into storage of a previous field, returns the offset in bits of where that s...
bool IsArtificial() const
uint64_t bit_offset
Offset of this field in bits from the beginning of the containing struct.
void SetEffectiveFieldEnd(uint64_t val)
bool NextBitfieldOffsetIsValid(const uint64_t next_bit_offset) const
uint64_t GetFieldEnd() const
Returns the offset in bits of where the storage this field occupies ends.
void SetIsBitfield(bool flag)
uint64_t bit_size
Size in bits that this field occupies.
bool is_bitfield
Set to 'true' if this field is a bit-field.
Parsed form of all attributes that are relevant for parsing type members.
std::optional< uint64_t > byte_size
int64_t bit_offset
Indicates how many bits into the word (according to the host endianness) the low-order bit of the fie...
uint32_t member_byte_offset
Indicates the byte offset of the word from the base address of the structure.
lldb_private::plugin::dwarf::DWARFFormValue encoding_form
size_t bit_size
Indicates the size of the field in bits.
std::optional< lldb_private::plugin::dwarf::DWARFFormValue > const_value_form
MemberAttributes(const lldb_private::plugin::dwarf::DWARFDIE &die, const lldb_private::plugin::dwarf::DWARFDIE &parent_die, lldb::ModuleSP module_sp)
Parsed form of all attributes that are relevant for type reconstruction.
clang::LangAS address_class
Address space class (translated from DW_AT_address_class).
lldb_private::Declaration decl
const char * mangled_name
lldb_private::ConstString name
std::optional< clang::EnumExtensibilityAttr::Kind > enum_kind
std::optional< uint64_t > alignment
bool is_complete_objc_class
lldb::LanguageType class_language
bool is_forward_declaration
std::optional< uint64_t > byte_size
lldb_private::plugin::dwarf::DWARFFormValue signature
lldb_private::plugin::dwarf::DWARFFormValue type
clang::StorageClass storage
ParsedDWARFTypeAttributes(const lldb_private::plugin::dwarf::DWARFDIE &die)
clang::RefQualifierKind ref_qual
Has a value if this DIE represents an enum that was declared with enum_extensibility.
lldb_private::plugin::dwarf::DWARFFormValue specification
lldb_private::plugin::dwarf::DWARFFormValue abstract_origin
std::optional< uint64_t > data_bit_size
lldb_private::plugin::dwarf::DWARFFormValue containing_type
size_t calling_convention
llvm::DenseMap< const clang::FieldDecl *, uint64_t > field_offsets
static clang::QualType GetQualType(const CompilerType &ct)
static CompilerType RemoveFastQualifiers(const CompilerType &ct)
static clang::TagDecl * GetAsTagDecl(const CompilerType &type)
Holds parsed information about a function call label that LLDB attaches as an AsmLabel to function AS...
std::string toString() const
Encode this FunctionCallLabel into its string representation.
lldb::user_id_t GetID() const
Get accessor for the user ID.