Skip to content

Commit d568483

Browse files
adrian-prantladrian-prantl
authored
Merge pull request swiftlang#7574 from adrian-prantl/116361792-5.9
Remove SwiftASTContext from SwiftMetatype_SummaryProvider
2 parents 52fae62 + 8094600 commit d568483

File tree

11 files changed

+143
-89
lines changed

11 files changed

+143
-89
lines changed

‎lldb/source/Plugins/Language/Swift/SwiftArray.cpp‎

Lines changed: 18 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@
1414

1515
#include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
1616
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
17-
#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
17+
#include "Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h"
1818
#include "lldb/Core/ValueObjectConstResult.h"
1919
#include "lldb/DataFormatters/FormattersHelpers.h"
2020
#include "lldb/Target/Process.h"
@@ -23,9 +23,6 @@
2323
// FIXME: we should not need this
2424
#include "Plugins/Language/ObjC/Cocoa.h"
2525

26-
#include "swift/AST/ASTContext.h"
27-
#include "llvm/ADT/StringRef.h"
28-
2926
using namespace lldb;
3027
using namespace lldb_private;
3128
using namespace lldb_private::formatters;
@@ -283,7 +280,10 @@ bool SwiftSyntheticFrontEndBufferHandler::IsValid() {
283280
}
284281

285282
std::unique_ptr<SwiftArrayBufferHandler>
286-
SwiftArrayBufferHandler::CreateBufferHandler(ValueObject &valobj) {
283+
SwiftArrayBufferHandler::CreateBufferHandler(ValueObject &static_valobj) {
284+
lldb::ValueObjectSP valobj_sp =
285+
static_valobj.GetDynamicValue(lldb::eDynamicCanRunTarget);
286+
ValueObject &valobj = valobj_sp ? *valobj_sp : static_valobj;
287287
llvm::StringRef valobj_typename(
288288
valobj.GetCompilerType().GetTypeName().AsCString(""));
289289

@@ -327,22 +327,24 @@ SwiftArrayBufferHandler::CreateBufferHandler(ValueObject &valobj) {
327327
if (error.Fail() || argmetadata_ptr == LLDB_INVALID_ADDRESS)
328328
return nullptr;
329329

330+
// Get the type of the array elements.
331+
CompilerType argument_type;
332+
auto scratch_ctx_reader = valobj.GetSwiftScratchContext();
333+
if (!scratch_ctx_reader)
334+
return nullptr;
335+
auto *ts = scratch_ctx_reader->get();
336+
if (!ts)
337+
return nullptr;
330338
auto *swift_runtime = SwiftLanguageRuntime::Get(process_sp);
331339
if (!swift_runtime)
332340
return nullptr;
333341

334-
CompilerType argument_type;
335-
336-
SwiftLanguageRuntime::MetadataPromiseSP promise_sp(
337-
swift_runtime->GetMetadataPromise(argmetadata_ptr, valobj));
338-
if (promise_sp)
339-
if (CompilerType type = promise_sp->FulfillTypePromise())
340-
if (auto type_system =
341-
type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>())
342-
argument_type =
343-
type_system->GetGenericArgumentType(type.GetOpaqueQualType(), 0);
342+
if (CompilerType type =
343+
swift_runtime->GetTypeFromMetadata(*ts, argmetadata_ptr))
344+
if (auto ts = type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>())
345+
argument_type = ts->GetGenericArgumentType(type.GetOpaqueQualType(), 0);
344346

345-
if (!argument_type.IsValid())
347+
if (!argument_type)
346348
return nullptr;
347349

348350
auto handler = std::unique_ptr<SwiftArrayBufferHandler>(

‎lldb/source/Plugins/Language/Swift/SwiftMetatype.cpp‎

Lines changed: 10 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
1-
//===-- SwiftMetatype.cpp ---------------------------------------*- C++ -*-===//
1+
//===-- SwiftMetatype.cpp -------------------------------------------------===//
22
//
33
// This source file is part of the Swift.org open source project
44
//
5-
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
5+
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
66
// Licensed under Apache License v2.0 with Runtime Library Exception
77
//
88
// See https://swift.org/LICENSE.txt for license information
@@ -12,12 +12,7 @@
1212

1313
#include "SwiftMetatype.h"
1414
#include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
15-
#include "lldb/Core/Mangled.h"
1615
#include "lldb/Symbol/CompilerType.h"
17-
#include "lldb/Target/Process.h"
18-
19-
#include "swift/AST/Type.h"
20-
#include "swift/AST/Types.h"
2116

2217
using namespace lldb;
2318
using namespace lldb_private;
@@ -26,30 +21,18 @@ using namespace lldb_private::formatters::swift;
2621

2722
bool lldb_private::formatters::swift::SwiftMetatype_SummaryProvider(
2823
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
24+
ConstString name;
2925
lldb::addr_t metadata_ptr = valobj.GetPointerValue();
3026
if (metadata_ptr == LLDB_INVALID_ADDRESS || metadata_ptr == 0) {
3127
CompilerType compiler_metatype_type(valobj.GetCompilerType());
3228
CompilerType instancetype =
3329
TypeSystemSwift::GetInstanceType(compiler_metatype_type);
34-
35-
const char *ptr = instancetype.GetDisplayTypeName().AsCString(nullptr);
36-
if (ptr && *ptr) {
37-
stream.Printf("%s", ptr);
38-
return true;
39-
}
40-
} else {
41-
auto swift_runtime = SwiftLanguageRuntime::Get(valobj.GetProcessSP());
42-
if (!swift_runtime)
43-
return false;
44-
SwiftLanguageRuntime::MetadataPromiseSP metadata_promise_sp =
45-
swift_runtime->GetMetadataPromise(metadata_ptr, valobj);
46-
if (!metadata_promise_sp)
47-
return false;
48-
if (CompilerType resolved_type =
49-
metadata_promise_sp->FulfillTypePromise()) {
50-
stream.Printf("%s", resolved_type.GetDisplayTypeName().AsCString());
51-
return true;
52-
}
30+
name = instancetype.GetDisplayTypeName();
31+
} else if (CompilerType meta_type = valobj.GetCompilerType()) {
32+
name = meta_type.GetDisplayTypeName();
5333
}
54-
return false;
34+
if (!name)
35+
return false;
36+
stream << name;
37+
return true;
5538
}

‎lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp‎

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -267,8 +267,7 @@ class SwiftLanguageRuntimeStub {
267267
return addr;
268268
}
269269

270-
SwiftLanguageRuntime::MetadataPromiseSP
271-
GetMetadataPromise(lldb::addr_t addr, ValueObject &for_object) {
270+
CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address addr) {
272271
STUB_LOG();
273272
return {};
274273
}
@@ -2382,10 +2381,9 @@ lldb::addr_t SwiftLanguageRuntime::FixupAddress(lldb::addr_t addr,
23822381
FORWARD(FixupAddress, addr, type, error);
23832382
}
23842383

2385-
SwiftLanguageRuntime::MetadataPromiseSP
2386-
SwiftLanguageRuntime::GetMetadataPromise(lldb::addr_t addr,
2387-
ValueObject &for_object) {
2388-
FORWARD(GetMetadataPromise, addr, for_object);
2384+
CompilerType SwiftLanguageRuntime::GetTypeFromMetadata(TypeSystemSwift &tss,
2385+
Address addr) {
2386+
FORWARD(GetTypeFromMetadata, tss, addr);
23892387
}
23902388

23912389
bool SwiftLanguageRuntime::IsStoredInlineInBuffer(CompilerType type) {

‎lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h‎

Lines changed: 1 addition & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -74,9 +74,6 @@ class SwiftLanguageRuntime : public LanguageRuntime {
7474
std::unique_ptr<SwiftLanguageRuntimeImpl> m_impl;
7575

7676
public:
77-
class MetadataPromise;
78-
typedef std::shared_ptr<MetadataPromise> MetadataPromiseSP;
79-
8077
static char ID;
8178

8279
bool isA(const void *ClassID) const override {
@@ -238,24 +235,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
238235
CompilerType GetConcreteType(ExecutionContextScope *exe_scope,
239236
ConstString abstract_type_name) override;
240237

241-
/// A proxy object to support lazy binding of Archetypes.
242-
class MetadataPromise {
243-
friend class SwiftLanguageRuntimeImpl;
244-
245-
MetadataPromise(ValueObject &, SwiftLanguageRuntimeImpl &, lldb::addr_t);
246-
247-
lldb::ValueObjectSP m_for_object_sp;
248-
SwiftLanguageRuntimeImpl &m_swift_runtime;
249-
lldb::addr_t m_metadata_location;
250-
llvm::Optional<swift::MetadataKind> m_metadata_kind;
251-
llvm::Optional<CompilerType> m_compiler_type;
252-
253-
public:
254-
CompilerType FulfillTypePromise(Status *error = nullptr);
255-
};
256-
257-
MetadataPromiseSP GetMetadataPromise(lldb::addr_t addr,
258-
ValueObject &for_object);
238+
CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address address);
259239
/// Build the artificial type metadata variable name for \p swift_type.
260240
static bool GetAbstractTypeName(StreamString &name, swift::Type swift_type);
261241

‎lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp‎

Lines changed: 73 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -472,14 +472,14 @@ void SwiftLanguageRuntimeImpl::PopLocalBuffer() {
472472
((LLDBMemoryReader *)GetMemoryReader().get())->popLocalBuffer();
473473
}
474474

475-
SwiftLanguageRuntime::MetadataPromise::MetadataPromise(
475+
SwiftLanguageRuntimeImpl::MetadataPromise::MetadataPromise(
476476
ValueObject &for_object, SwiftLanguageRuntimeImpl &runtime,
477477
lldb::addr_t location)
478478
: m_for_object_sp(for_object.GetSP()), m_swift_runtime(runtime),
479479
m_metadata_location(location) {}
480480

481481
CompilerType
482-
SwiftLanguageRuntime::MetadataPromise::FulfillTypePromise(Status *error) {
482+
SwiftLanguageRuntimeImpl::MetadataPromise::FulfillTypePromise(Status *error) {
483483
if (error)
484484
error->Clear();
485485

@@ -532,7 +532,7 @@ SwiftLanguageRuntime::MetadataPromise::FulfillTypePromise(Status *error) {
532532
}
533533
}
534534

535-
SwiftLanguageRuntime::MetadataPromiseSP
535+
SwiftLanguageRuntimeImpl::MetadataPromiseSP
536536
SwiftLanguageRuntimeImpl::GetMetadataPromise(lldb::addr_t addr,
537537
ValueObject &for_object) {
538538
llvm::Optional<SwiftScratchContextReader> maybe_swift_scratch_ctx =
@@ -555,8 +555,8 @@ SwiftLanguageRuntimeImpl::GetMetadataPromise(lldb::addr_t addr,
555555
if (iter != m_promises_map.end())
556556
return iter->second;
557557

558-
SwiftLanguageRuntime::MetadataPromiseSP promise_sp(
559-
new SwiftLanguageRuntime::MetadataPromise(for_object, *this, addr));
558+
SwiftLanguageRuntimeImpl::MetadataPromiseSP promise_sp(
559+
new SwiftLanguageRuntimeImpl::MetadataPromise(for_object, *this, addr));
560560
m_promises_map.insert({key, promise_sp});
561561
return promise_sp;
562562
}
@@ -2284,6 +2284,65 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Protocol(
22842284
return true;
22852285
}
22862286

2287+
bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_ExistentialMetatype(
2288+
ValueObject &in_value, CompilerType meta_type,
2289+
lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name,
2290+
Address &address) {
2291+
// Resolve the dynamic type of the metatype.
2292+
AddressType address_type;
2293+
lldb::addr_t ptr = in_value.GetPointerValue(&address_type);
2294+
if (ptr == LLDB_INVALID_ADDRESS || ptr == 0)
2295+
return false;
2296+
2297+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
2298+
if (!reflection_ctx)
2299+
return false;
2300+
2301+
const swift::reflection::TypeRef *type_ref =
2302+
reflection_ctx->readTypeFromMetadata(ptr);
2303+
2304+
auto tss = meta_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
2305+
if (!tss)
2306+
return false;
2307+
auto &ts = tss->GetTypeSystemSwiftTypeRef();
2308+
2309+
using namespace swift::Demangle;
2310+
Demangler dem;
2311+
NodePointer node = type_ref->getDemangling(dem);
2312+
// Wrap the resolved type in a metatype again for the data formatter to
2313+
// recognize.
2314+
if (!node || node->getKind() != Node::Kind::Type)
2315+
return false;
2316+
NodePointer wrapped = dem.createNode(Node::Kind::Type);
2317+
NodePointer meta = dem.createNode(Node::Kind::Metatype);
2318+
meta->addChild(node, dem);
2319+
wrapped->addChild(meta,dem);
2320+
2321+
meta_type = ts.GetTypeSystemSwiftTypeRef().RemangleAsType(dem, wrapped);
2322+
class_type_or_name.SetCompilerType(meta_type);
2323+
address.SetRawAddress(ptr);
2324+
return true;
2325+
}
2326+
2327+
CompilerType SwiftLanguageRuntimeImpl::GetTypeFromMetadata(TypeSystemSwift &ts,
2328+
Address address) {
2329+
lldb::addr_t ptr = address.GetLoadAddress(&GetProcess().GetTarget());
2330+
if (ptr == LLDB_INVALID_ADDRESS)
2331+
return {};
2332+
2333+
ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
2334+
if (!reflection_ctx)
2335+
return {};
2336+
2337+
const swift::reflection::TypeRef *type_ref =
2338+
reflection_ctx->readTypeFromMetadata(ptr);
2339+
2340+
using namespace swift::Demangle;
2341+
Demangler dem;
2342+
NodePointer node = type_ref->getDemangling(dem);
2343+
return ts.GetTypeSystemSwiftTypeRef().RemangleAsType(dem, node);
2344+
}
2345+
22872346
llvm::Optional<lldb::addr_t>
22882347
SwiftLanguageRuntimeImpl::GetTypeMetadataForTypeNameAndFrame(
22892348
StringRef mdvar_name, StackFrame &frame) {
@@ -2308,7 +2367,7 @@ SwiftLanguageRuntimeImpl::GetTypeMetadataForTypeNameAndFrame(
23082367
return metadata_location;
23092368
}
23102369

2311-
SwiftLanguageRuntime::MetadataPromiseSP
2370+
SwiftLanguageRuntimeImpl::MetadataPromiseSP
23122371
SwiftLanguageRuntimeImpl::GetPromiseForTypeNameAndFrame(const char *type_name,
23132372
StackFrame *frame) {
23142373
if (!frame || !type_name || !type_name[0])
@@ -3161,11 +3220,16 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress(
31613220
in_value, use_dynamic, class_type_or_name, address, static_value_type);
31623221
else if (type_info.AnySet(eTypeIsPack))
31633222
success = GetDynamicTypeAndAddress_Pack(in_value, val_type, use_dynamic,
3164-
class_type_or_name, address, static_value_type);
3223+
class_type_or_name, address,
3224+
static_value_type);
31653225
else if (type_info.AnySet(eTypeIsClass) ||
31663226
type_info.AllSet(eTypeIsBuiltIn | eTypeIsPointer | eTypeHasValue))
31673227
success = GetDynamicTypeAndAddress_Class(in_value, val_type, use_dynamic,
3168-
class_type_or_name, address, static_value_type);
3228+
class_type_or_name, address,
3229+
static_value_type);
3230+
else if (type_info.AllSet(eTypeIsMetatype | eTypeIsProtocol))
3231+
success = GetDynamicTypeAndAddress_ExistentialMetatype(
3232+
in_value, val_type, use_dynamic, class_type_or_name, address);
31693233
else if (type_info.AnySet(eTypeIsProtocol))
31703234
success = GetDynamicTypeAndAddress_Protocol(in_value, val_type, use_dynamic,
31713235
class_type_or_name, address);
@@ -3498,7 +3562,7 @@ SwiftLanguageRuntimeImpl::GetConcreteType(ExecutionContextScope *exe_scope,
34983562
if (!frame)
34993563
return CompilerType();
35003564

3501-
SwiftLanguageRuntime::MetadataPromiseSP promise_sp(
3565+
SwiftLanguageRuntimeImpl::MetadataPromiseSP promise_sp(
35023566
GetPromiseForTypeNameAndFrame(abstract_type_name.GetCString(), frame));
35033567
if (!promise_sp)
35043568
return CompilerType();

‎lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeImpl.h‎

Lines changed: 27 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -107,8 +107,7 @@ class SwiftLanguageRuntimeImpl {
107107
llvm::Optional<size_t> GetBitAlignment(CompilerType type,
108108
ExecutionContextScope *exe_scope);
109109

110-
SwiftLanguageRuntime::MetadataPromiseSP
111-
GetMetadataPromise(lldb::addr_t addr, ValueObject &for_object);
110+
CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address address);
112111

113112
llvm::Optional<uint64_t>
114113
GetMemberVariableOffsetRemoteAST(CompilerType instance_type,
@@ -322,6 +321,11 @@ class SwiftLanguageRuntimeImpl {
322321
TypeAndOrName &class_type_or_name,
323322
Address &address);
324323

324+
bool GetDynamicTypeAndAddress_ExistentialMetatype(
325+
ValueObject &in_value, CompilerType meta_type,
326+
lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name,
327+
Address &address);
328+
325329
bool GetDynamicTypeAndAddress_Value(ValueObject &in_value,
326330
CompilerType &bound_type,
327331
lldb::DynamicValueType use_dynamic,
@@ -340,7 +344,26 @@ class SwiftLanguageRuntimeImpl {
340344
Address &address,
341345
Value::ValueType &value_type);
342346

343-
SwiftLanguageRuntime::MetadataPromiseSP
347+
/// A proxy object to support lazy binding of Archetypes.
348+
class MetadataPromise {
349+
friend class SwiftLanguageRuntimeImpl;
350+
351+
MetadataPromise(ValueObject &, SwiftLanguageRuntimeImpl &, lldb::addr_t);
352+
353+
lldb::ValueObjectSP m_for_object_sp;
354+
SwiftLanguageRuntimeImpl &m_swift_runtime;
355+
lldb::addr_t m_metadata_location;
356+
llvm::Optional<swift::MetadataKind> m_metadata_kind;
357+
llvm::Optional<CompilerType> m_compiler_type;
358+
359+
public:
360+
CompilerType FulfillTypePromise(Status *error = nullptr);
361+
};
362+
typedef std::shared_ptr<MetadataPromise> MetadataPromiseSP;
363+
364+
MetadataPromiseSP GetMetadataPromise(lldb::addr_t addr,
365+
ValueObject &for_object);
366+
MetadataPromiseSP
344367
GetPromiseForTypeNameAndFrame(const char *type_name, StackFrame *frame);
345368

346369
llvm::Optional<lldb::addr_t>
@@ -371,7 +394,7 @@ class SwiftLanguageRuntimeImpl {
371394
std::shared_ptr<LLDBMemoryReader> m_memory_reader_sp;
372395

373396
llvm::DenseMap<std::pair<swift::ASTContext *, lldb::addr_t>,
374-
SwiftLanguageRuntime::MetadataPromiseSP>
397+
MetadataPromiseSP>
375398
m_promises_map;
376399

377400
llvm::DenseMap<swift::ASTContext *,

0 commit comments

Comments
 (0)