Skip to content

Commit c1392fc

Browse files
adrian-prantladrian-prantl
committed
WIP
1 parent 5b54e12 commit c1392fc

File tree

4 files changed

+180
-64
lines changed

4 files changed

+180
-64
lines changed

‎lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwift.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,8 @@ class DWARFASTParserSwift : public lldb_private::plugin::dwarf::DWARFASTParser,
3737

3838
virtual ~DWARFASTParserSwift();
3939

40+
static std::pair<lldb::TypeSP, lldb_private::CompilerType>
41+
ResolveTypeAlias(lldb_private::CompilerType alias);
4042
lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
4143
const DWARFDIE &die,
4244
bool *type_is_new_ptr) override;

‎lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwiftDescriptorFinder.cpp‎

Lines changed: 78 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,76 @@ findUnsubstitutedGenericTypeAndDIE(TypeSystemSwiftTypeRef &ts,
5656
ts.GetTypeFromMangledTypename(ConstString(mangled_name));
5757
return {{unsubstituted_type, unsubstituted_die}};
5858
}
59+
60+
lldb_private::CompilerType static MapTypeIntoContext(
61+
TypeSystemSwiftTypeRef &ts, lldb_private::CompilerType other,
62+
lldb_private::CompilerType type) {
63+
return ts.ApplySubstitutions(type.GetOpaqueQualType(),
64+
ts.GetSubstitutions(other.GetOpaqueQualType()));
65+
}
66+
67+
std::pair<lldb::TypeSP, lldb_private::CompilerType>
68+
DWARFASTParserSwift::ResolveTypeAlias(lldb_private::CompilerType alias) {
69+
if (!alias)
70+
return {};
71+
auto ts_sp = alias.GetTypeSystem().dyn_cast_or_null<TypeSystemSwiftTypeRef>();
72+
if (!ts_sp)
73+
return {};
74+
auto &ts = *ts_sp;
75+
auto *dwarf = llvm::cast_or_null<SymbolFileDWARF>(ts.GetSymbolFile());
76+
if (!dwarf)
77+
return {};
78+
79+
// Type aliases are (for LLVM implementation reasons) using the
80+
// DW_AT_name as linkage name, so they can't be looked up by base
81+
// name. This should be fixed.
82+
// Meanwhile, instead find them inside their parent type.
83+
auto parent_ctx = ts.GetParentType(alias.GetOpaqueQualType());
84+
if (!parent_ctx)
85+
return {};
86+
87+
DWARFDIE parent_die;
88+
if (TypeSP parent_type =
89+
ts.FindTypeInModule(parent_ctx.GetOpaqueQualType())) {
90+
parent_die = dwarf->GetDIE(parent_type->GetID());
91+
auto unsubstituted_pair =
92+
findUnsubstitutedGenericTypeAndDIE(ts, parent_die);
93+
if (unsubstituted_pair)
94+
parent_die = unsubstituted_pair->second;
95+
}
96+
if (!parent_die)
97+
return {};
98+
for (DWARFDIE child_die : parent_die.children()) {
99+
auto tag = child_die.Tag();
100+
if (tag == DW_TAG_member)
101+
continue;
102+
StringRef base_name;
103+
const auto *name =
104+
child_die.GetAttributeValueAsString(llvm::dwarf::DW_AT_name, "");
105+
if (name && *name == '$') {
106+
CompilerType candidate = ts.GetTypeFromMangledTypename(ConstString(name));
107+
base_name = ts.GetBaseName(candidate.GetOpaqueQualType());
108+
} else {
109+
base_name = name;
110+
}
111+
if (base_name != ts.GetBaseName(alias.GetOpaqueQualType()))
112+
continue;
113+
114+
// Follow the typedef.
115+
auto *dwarf_parser = ts.GetDWARFParser();
116+
if (!dwarf_parser)
117+
return {};
118+
Type *t = dwarf_parser->GetTypeForDIE(child_die);
119+
if (!t)
120+
return {};
121+
CompilerType cty = t->GetForwardCompilerType();
122+
if (ts.IsMeaninglessWithoutDynamicResolution(cty.GetOpaqueQualType()))
123+
return {{}, MapTypeIntoContext(ts, alias, cty)};
124+
return {t->shared_from_this(), cty};
125+
}
126+
return {};
127+
}
128+
59129
/// Given a type system and a typeref, return the compiler type and die of the
60130
/// type that matches that mangled name, looking up the in the type system's
61131
/// module's debug information.
@@ -81,60 +151,14 @@ getTypeAndDie(TypeSystemSwiftTypeRef &ts,
81151
return {};
82152
TypeSP lldb_type = ts.FindTypeInModule(type.GetOpaqueQualType());
83153
if (!lldb_type) {
84-
// Type aliases are (for LLVM implementation reasons) using the
85-
// DW_AT_name as linkage name, so they can't be looked up by base
86-
// name. This should be fixed.
87-
// Meanwhile, instead find them inside their parent type.
88-
if (auto parent_ctx = ts.GetParentType(type.GetOpaqueQualType())) {
89-
90-
DWARFDIE parent_die;
91-
if (TypeSP parent_type =
92-
ts.FindTypeInModule(parent_ctx.GetOpaqueQualType())) {
93-
parent_die = dwarf->GetDIE(parent_type->GetID());
94-
auto unsubstituted_pair =
95-
findUnsubstitutedGenericTypeAndDIE(ts, parent_die);
96-
if (unsubstituted_pair)
97-
parent_die = unsubstituted_pair->second;
98-
}
99-
if (parent_die) {
100-
for (DWARFDIE child_die : parent_die.children()) {
101-
auto tag = child_die.Tag();
102-
if (tag == DW_TAG_member)
103-
continue;
104-
StringRef base_name;
105-
{
106-
const auto *name = child_die.GetAttributeValueAsString(
107-
llvm::dwarf::DW_AT_name, "");
108-
if (name && *name == '$') {
109-
CompilerType candidate =
110-
ts.GetTypeFromMangledTypename(ConstString(name));
111-
base_name = ts.GetBaseName(candidate.GetOpaqueQualType());
112-
} else {
113-
base_name = name;
114-
}
115-
}
116-
if (base_name == ts.GetBaseName(type.GetOpaqueQualType())) {
117-
// Follow the typedef.
118-
auto *dwarf_parser = ts.GetDWARFParser();
119-
if (!dwarf_parser)
120-
return {};
121-
Type *t = dwarf_parser->GetTypeForDIE(child_die);
122-
if (!t)
123-
return {};
124-
lldb_type = t->shared_from_this();
125-
type = lldb_type->GetForwardCompilerType();
126-
break;
127-
}
128-
}
129-
}
130-
}
131-
if (!lldb_type) {
132-
// TODO: for embedded Swift this is fine but consult other modules
133-
// here for general case?
134-
LLDB_LOGV(GetLog(LLDBLog::Types), "Could not find type {0} in module",
135-
type.GetMangledTypeName());
136-
return {};
137-
}
154+
std::tie(lldb_type, type) = DWARFASTParserSwift::ResolveTypeAlias(type);
155+
}
156+
if (!lldb_type) {
157+
// TODO: for embedded Swift this is fine but consult other modules
158+
// here for general case?
159+
LLDB_LOGV(GetLog(LLDBLog::Types), "Could not find type {0} in module",
160+
type.GetMangledTypeName());
161+
return {};
138162
}
139163
auto die = dwarf->GetDIE(lldb_type->GetID());
140164

‎lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp‎

Lines changed: 95 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1053,7 +1053,22 @@ TypeSystemSwiftTypeRef::ResolveTypeAlias(swift::Demangle::Demangler &dem,
10531053
}
10541054
}
10551055

1056-
if (prefer_clang_types || !results.Done(query)) {
1056+
1057+
TypeSP type;
1058+
if (results.Done(query))
1059+
type = results.GetFirstType();
1060+
1061+
// Find the type by declcontext (-gdwarf-types).
1062+
if (!type) {
1063+
auto resolved = DWARFASTParserSwift::ResolveTypeAlias(
1064+
GetTypeFromMangledTypename(mangled));
1065+
if (resolved.second) {
1066+
NodePointer n = GetDemangledType(dem, resolved.second.GetMangledTypeName());
1067+
return {n, {}};
1068+
}
1069+
}
1070+
1071+
if (prefer_clang_types || !type) {
10571072
// No Swift type found -- this could be a Clang typedef. This
10581073
// check is not done earlier because a Clang typedef that points
10591074
// to a builtin type, e.g., "typedef unsigned uint32_t", could
@@ -1066,7 +1081,6 @@ TypeSystemSwiftTypeRef::ResolveTypeAlias(swift::Demangle::Demangler &dem,
10661081
return {{}, clang_type};
10671082
}
10681083

1069-
TypeSP type = results.GetFirstType();
10701084
if (!type) {
10711085
LLDB_LOGF(GetLog(LLDBLog::Types), "Found empty type alias %s",
10721086
mangled.AsCString());
@@ -1097,14 +1111,8 @@ TypeSystemSwiftTypeRef::ResolveTypeAlias(swift::Demangle::Demangler &dem,
10971111
return {n, {}};
10981112
}
10991113

1100-
CompilerType
1101-
TypeSystemSwiftTypeRef::GetParentType(lldb::opaque_compiler_type_t type) {
1102-
using namespace swift::Demangle;
1103-
Demangler dem;
1104-
const char *mangled_typename = AsMangledName(type);
1105-
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_typename);
1106-
NodePointer node =
1107-
swift_demangle::GetDemangledTypeMangling(dem, mangled_typename);
1114+
static swift::Demangle::NodePointer
1115+
GetParentNode(swift::Demangle::NodePointer node) {
11081116
if (!node || node->getKind() != Node::Kind::Type || !node->hasChildren())
11091117
return {};
11101118
node = node->getChild(0);
@@ -1125,6 +1133,18 @@ TypeSystemSwiftTypeRef::GetParentType(lldb::opaque_compiler_type_t type) {
11251133
default:
11261134
break;
11271135
}
1136+
return parent_node;
1137+
}
1138+
1139+
CompilerType
1140+
TypeSystemSwiftTypeRef::GetParentType(lldb::opaque_compiler_type_t type) {
1141+
using namespace swift::Demangle;
1142+
Demangler dem;
1143+
const char *mangled_typename = AsMangledName(type);
1144+
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_typename);
1145+
NodePointer node =
1146+
swift_demangle::GetDemangledTypeMangling(dem, mangled_typename);
1147+
NodePointer parent_node = GetParentNode(node);
11281148
if (!parent_node) {
11291149
LLDB_LOGF(GetLog(LLDBLog::Types), "Could not determine declcontext of %s.",
11301150
mangled_typename);
@@ -1135,6 +1155,71 @@ TypeSystemSwiftTypeRef::GetParentType(lldb::opaque_compiler_type_t type) {
11351155
return RemangleAsType(dem, type_node, flavor);
11361156
}
11371157

1158+
std::vector<std::vector<CompilerType>>
1159+
TypeSystemSwiftTypeRef::GetSubstitutions(lldb::opaque_compiler_type_t type) {
1160+
using namespace swift::Demangle;
1161+
Demangler dem;
1162+
const char *mangled_typename = AsMangledName(type);
1163+
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_typename);
1164+
NodePointer type_node =
1165+
swift_demangle::GetDemangledTypeMangling(dem, mangled_typename);
1166+
1167+
std::vector<std::vector<CompilerType>> all_subs;
1168+
for (NodePointer node = GetParentNode(type_node); node;
1169+
node = GetParentNode(node)) {
1170+
all_subs.push_back({});
1171+
std::vector<CompilerType> &subs = all_subs.back();
1172+
switch (node->getKind()) {
1173+
case Node::Kind::BoundGenericStructure: {
1174+
if (node->getNumChildren() == 2) {
1175+
if (NodePointer params = node->getChild(1))
1176+
for (NodePointer t : *params) {
1177+
subs.push_back(RemangleAsType(dem, t, flavor));
1178+
}
1179+
}
1180+
break;
1181+
}
1182+
default:
1183+
break;
1184+
}
1185+
}
1186+
return all_subs;
1187+
}
1188+
1189+
CompilerType TypeSystemSwiftTypeRef::ApplySubstitutions(
1190+
lldb::opaque_compiler_type_t type,
1191+
std::vector<std::vector<CompilerType>> subs) {
1192+
using namespace swift::Demangle;
1193+
Demangler dem;
1194+
const char *mangled_typename = AsMangledName(type);
1195+
auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_typename);
1196+
NodePointer node =
1197+
swift_demangle::GetDemangledTypeMangling(dem, mangled_typename);
1198+
1199+
node = Transform(dem, node, [&](NodePointer node) {
1200+
if (!node || node->getKind() != Node::Kind::DependentGenericParamType ||
1201+
node->getNumChildren() != 2)
1202+
return node;
1203+
NodePointer depth_node = node->getChild(0);
1204+
NodePointer index_node = node->getChild(1);
1205+
if (!depth_node->hasIndex() || !index_node->hasIndex())
1206+
return node;
1207+
unsigned depth = depth_node->getIndex();
1208+
unsigned index = index_node->getIndex();
1209+
if (depth >= subs.size())
1210+
return node;
1211+
if (index >= subs[depth].size())
1212+
return node;
1213+
CompilerType sub = subs[depth][index];
1214+
return swift_demangle::GetDemangledTypeMangling(dem,
1215+
sub.GetMangledTypeName());
1216+
});
1217+
1218+
NodePointer type_node = dem.createNode(Node::Kind::Type);
1219+
type_node->addChild(node, dem);
1220+
return RemangleAsType(dem, type_node, flavor);
1221+
}
1222+
11381223
std::optional<TypeSystemSwift::TupleElement>
11391224
TypeSystemSwiftTypeRef::GetTupleElement(lldb::opaque_compiler_type_t type,
11401225
size_t idx) {

‎lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -139,6 +139,11 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
139139
}
140140

141141
CompilerType GetParentType(lldb::opaque_compiler_type_t type);
142+
std::vector<std::vector<CompilerType>>
143+
GetSubstitutions(lldb::opaque_compiler_type_t type);
144+
CompilerType ApplySubstitutions(lldb::opaque_compiler_type_t type,
145+
std::vector<std::vector<CompilerType>> subs);
146+
142147
Module *GetModule() const { return m_module; }
143148

144149
/// Return a key for the SwiftASTContext map. If there is debug info it's the

0 commit comments

Comments
 (0)