Skip to content

Commit 6c779bb

Browse files
jckarterjckarter
authored
Merge pull request #24445 from jckarter/opaque-type-remote
Debugger support for opaque types.
2 parents f978cb0 + edd3015 commit 6c779bb

File tree

20 files changed

+343
-87
lines changed

20 files changed

+343
-87
lines changed

‎include/swift/ABI/Metadata.h

Lines changed: 13 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -457,6 +457,7 @@ template <typename Runtime> struct TargetStructMetadata;
457457
template <typename Runtime> struct TargetOpaqueMetadata;
458458
template <typename Runtime> struct TargetValueMetadata;
459459
template <typename Runtime> struct TargetForeignClassMetadata;
460+
template <typename Runtime> struct TargetContextDescriptor;
460461
template <typename Runtime> class TargetTypeContextDescriptor;
461462
template <typename Runtime> class TargetClassDescriptor;
462463
template <typename Runtime> class TargetValueTypeDescriptor;
@@ -2085,12 +2086,12 @@ struct TargetTypeMetadataRecord {
20852086
private:
20862087
union {
20872088
/// A direct reference to a nominal type descriptor.
2088-
RelativeDirectPointerIntPair<TargetTypeContextDescriptor<Runtime>,
2089+
RelativeDirectPointerIntPair<TargetContextDescriptor<Runtime>,
20892090
TypeReferenceKind>
20902091
DirectNominalTypeDescriptor;
20912092

20922093
/// An indirect reference to a nominal type descriptor.
2093-
RelativeDirectPointerIntPair<TargetTypeContextDescriptor<Runtime> * const,
2094+
RelativeDirectPointerIntPair<TargetContextDescriptor<Runtime> * const,
20942095
TypeReferenceKind>
20952096
IndirectNominalTypeDescriptor;
20962097

@@ -2103,8 +2104,8 @@ struct TargetTypeMetadataRecord {
21032104
return DirectNominalTypeDescriptor.getInt();
21042105
}
21052106

2106-
const TargetTypeContextDescriptor<Runtime> *
2107-
getTypeContextDescriptor() const {
2107+
const TargetContextDescriptor<Runtime> *
2108+
getContextDescriptor() const {
21082109
switch (getTypeKind()) {
21092110
case TypeReferenceKind::DirectTypeDescriptor:
21102111
return DirectNominalTypeDescriptor.getPointer();
@@ -3043,11 +3044,16 @@ struct TargetOpaqueTypeDescriptor final
30433044
return getNumUnderlyingTypeArguments();
30443045
}
30453046

3047+
const RelativeDirectPointer<const char> &
3048+
getUnderlyingTypeArgumentMangledName(unsigned i) const {
3049+
assert(i < getNumUnderlyingTypeArguments());
3050+
return (this
3051+
->template getTrailingObjects<RelativeDirectPointer<const char>>())[i];
3052+
}
3053+
30463054
StringRef getUnderlyingTypeArgument(unsigned i) const {
30473055
assert(i < getNumUnderlyingTypeArguments());
3048-
const char *ptr =
3049-
(this->template getTrailingObjects<RelativeDirectPointer<const char>>())[i];
3050-
3056+
const char *ptr = getUnderlyingTypeArgumentMangledName(i);
30513057
return Demangle::makeSymbolicMangledNameStringRef(ptr);
30523058
}
30533059

‎include/swift/AST/ASTMangler.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -171,6 +171,8 @@ class ASTMangler : public Mangler {
171171

172172
std::string mangleTypeForDebugger(Type decl, const DeclContext *DC);
173173

174+
std::string mangleOpaqueTypeDescriptor(const OpaqueTypeDecl *decl);
175+
174176
std::string mangleDeclType(const ValueDecl *decl);
175177

176178
std::string mangleObjCRuntimeName(const NominalTypeDecl *Nominal);

‎include/swift/AST/Types.h

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4803,6 +4803,18 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
48034803
return T->getKind() == TypeKind::OpaqueTypeArchetype;
48044804
}
48054805

4806+
/// Get the ordinal of the type within the declaration's opaque signature.
4807+
///
4808+
/// If a method declared its return type as:
4809+
///
4810+
/// func foo() -> (some P, some Q)
4811+
///
4812+
/// then the underlying type of `some P` would be ordinal 0, and `some Q` would be ordinal 1.
4813+
unsigned getOrdinal() const {
4814+
// TODO: multiple opaque types
4815+
return 0;
4816+
}
4817+
48064818
static void Profile(llvm::FoldingSetNodeID &ID,
48074819
OpaqueTypeDecl *OpaqueDecl,
48084820
SubstitutionMap Substitutions);

‎include/swift/IRGen/Linking.h

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -770,9 +770,10 @@ class LinkEntity {
770770
return entity;
771771
}
772772

773-
static LinkEntity forAnonymousDescriptor(DeclContext *dc) {
773+
static LinkEntity forAnonymousDescriptor(
774+
PointerUnion<DeclContext *, VarDecl *> dc) {
774775
LinkEntity entity;
775-
entity.Pointer = const_cast<void*>(static_cast<const void*>(dc));
776+
entity.Pointer = dc.getOpaqueValue();
776777
entity.SecondaryPointer = nullptr;
777778
entity.Data =
778779
LINKENTITY_SET_FIELD(Kind, unsigned(Kind::AnonymousDescriptor));
@@ -1015,9 +1016,10 @@ class LinkEntity {
10151016
return reinterpret_cast<ExtensionDecl*>(Pointer);
10161017
}
10171018

1018-
const DeclContext *getDeclContext() const {
1019+
const PointerUnion<DeclContext *, VarDecl *> getAnonymousDeclContext() const {
10191020
assert(getKind() == Kind::AnonymousDescriptor);
1020-
return reinterpret_cast<DeclContext*>(Pointer);
1021+
return PointerUnion<DeclContext *, VarDecl *>
1022+
::getFromOpaqueValue(reinterpret_cast<void*>(Pointer));
10211023
}
10221024

10231025
SILFunction *getSILFunction() const {

‎include/swift/Remote/MetadataReader.h

Lines changed: 58 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -724,6 +724,35 @@ class MetadataReader {
724724
return nullptr;
725725
return buildContextMangling(context, Dem);
726726
}
727+
728+
/// Read the mangled underlying type from an opaque type descriptor.
729+
BuiltType
730+
readUnderlyingTypeForOpaqueTypeDescriptor(StoredPointer contextAddr,
731+
unsigned ordinal) {
732+
auto context = readContextDescriptor(contextAddr);
733+
if (!context)
734+
return BuiltType();
735+
if (context->getKind() != ContextDescriptorKind::OpaqueType)
736+
return BuiltType();
737+
738+
auto opaqueType =
739+
reinterpret_cast<const TargetOpaqueTypeDescriptor<Runtime> *>(
740+
context.getLocalBuffer());
741+
742+
if (ordinal >= opaqueType->getNumUnderlyingTypeArguments())
743+
return BuiltType();
744+
745+
auto nameAddr = resolveRelativeField(context,
746+
opaqueType->getUnderlyingTypeArgumentMangledName(ordinal));
747+
748+
Demangle::Demangler Dem;
749+
auto node = readMangledName(RemoteAddress(nameAddr),
750+
MangledNameKind::Type, Dem);
751+
if (!node)
752+
return BuiltType();
753+
754+
return decodeMangledType(node);
755+
}
727756

728757
bool isTaggedPointer(StoredPointer objectAddress) {
729758
if (getTaggedPointerEncoding() != TaggedPointerEncodingKind::Extended)
@@ -1396,6 +1425,12 @@ class MetadataReader {
13961425
case ContextDescriptorKind::Protocol:
13971426
baseSize = sizeof(TargetProtocolDescriptor<Runtime>);
13981427
break;
1428+
case ContextDescriptorKind::OpaqueType:
1429+
baseSize = sizeof(TargetOpaqueTypeDescriptor<Runtime>);
1430+
metadataInitSize =
1431+
sizeof(typename Runtime::template RelativeDirectPointer<const char>)
1432+
* flags.getKindSpecificFlags();
1433+
break;
13991434
default:
14001435
// We don't know about this kind of context.
14011436
return nullptr;
@@ -2076,6 +2111,29 @@ class MetadataReader {
20762111
// contexts; just create the node directly here and return.
20772112
return dem.createNode(nodeKind, std::move(moduleName));
20782113
}
2114+
2115+
case ContextDescriptorKind::OpaqueType: {
2116+
// The opaque type may have a named anonymous context for us to map
2117+
// back to its defining decl.
2118+
if (!parentDescriptorResult)
2119+
return nullptr;
2120+
auto anonymous =
2121+
dyn_cast_or_null<TargetAnonymousContextDescriptor<Runtime>>(
2122+
parentDescriptorResult->getLocalBuffer());
2123+
if (!anonymous)
2124+
return nullptr;
2125+
2126+
auto mangledNode =
2127+
demangleAnonymousContextName(*parentDescriptorResult, dem);
2128+
if (!mangledNode)
2129+
return nullptr;
2130+
if (mangledNode->getKind() == Node::Kind::Global)
2131+
mangledNode = mangledNode->getChild(0);
2132+
2133+
auto opaqueNode = dem.createNode(Node::Kind::OpaqueReturnTypeOf);
2134+
opaqueNode->addChild(mangledNode, dem);
2135+
return opaqueNode;
2136+
}
20792137

20802138
default:
20812139
// Not a kind of context we know about.

‎include/swift/RemoteAST/RemoteAST.h

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -240,6 +240,17 @@ class RemoteASTContext {
240240
Result<OpenedExistential>
241241
getDynamicTypeAndAddressForExistential(remote::RemoteAddress address,
242242
Type staticType);
243+
244+
/// Given a reference to an opaque type descriptor, an ordinal, and a set
245+
/// of substitutions, get the underlying type for the opaque type.
246+
///
247+
/// This does not recursively apply the transformation if the underlying
248+
/// type in turn refers to another opaque type.
249+
Result<Type>
250+
getUnderlyingTypeForOpaqueType(remote::RemoteAddress opaqueDescriptor,
251+
SubstitutionMap substitutions,
252+
unsigned ordinal);
253+
243254
};
244255

245256
} // end namespace remoteAST

‎lib/AST/ASTDemangler.cpp

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -255,11 +255,14 @@ Type ASTBuilder::resolveOpaqueType(NodePointer opaqueDescriptor,
255255
unsigned ordinal) {
256256
if (opaqueDescriptor->getKind() == Node::Kind::OpaqueReturnTypeOf) {
257257
auto definingDecl = opaqueDescriptor->getChild(0);
258-
auto mangledName = mangleNode(definingDecl);
258+
auto definingGlobal = Factory.createNode(Node::Kind::Global);
259+
definingGlobal->addChild(definingDecl, Factory);
260+
auto mangledName = mangleNode(definingGlobal);
261+
259262
auto moduleNode = findModuleNode(definingDecl);
260263
if (!moduleNode)
261264
return Type();
262-
auto parentModule = findModule(findModuleNode(definingDecl));
265+
auto parentModule = findModule(moduleNode);
263266
if (!parentModule)
264267
return Type();
265268

‎lib/AST/ASTMangler.cpp

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2679,3 +2679,10 @@ void ASTMangler::appendOpParamForLayoutConstraint(LayoutConstraint layout) {
26792679
break;
26802680
}
26812681
}
2682+
2683+
std::string ASTMangler::mangleOpaqueTypeDescriptor(const OpaqueTypeDecl *decl) {
2684+
beginMangling();
2685+
appendOpaqueDeclName(decl);
2686+
appendOperator("MQ");
2687+
return finalize();
2688+
}

‎lib/IRGen/GenDecl.cpp

Lines changed: 36 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -826,14 +826,16 @@ void IRGenModule::addObjCClass(llvm::Constant *classPtr, bool nonlazy) {
826826
ObjCNonLazyClasses.push_back(classPtr);
827827
}
828828

829-
void IRGenModule::addRuntimeResolvableType(NominalTypeDecl *nominal) {
829+
void IRGenModule::addRuntimeResolvableType(GenericTypeDecl *type) {
830830
// Collect the nominal type records we emit into a special section.
831-
RuntimeResolvableTypes.push_back(nominal);
831+
RuntimeResolvableTypes.push_back(type);
832832

833-
// As soon as the type metadata is available, all the type's conformances
834-
// must be available, too. The reason is that a type (with the help of its
835-
// metadata) can be checked at runtime if it conforms to a protocol.
836-
addLazyConformances(nominal);
833+
if (auto nominal = dyn_cast<NominalTypeDecl>(type)) {
834+
// As soon as the type metadata is available, all the type's conformances
835+
// must be available, too. The reason is that a type (with the help of its
836+
// metadata) can be checked at runtime if it conforms to a protocol.
837+
addLazyConformances(nominal);
838+
}
837839
}
838840

839841
ConstantReference
@@ -2744,41 +2746,49 @@ getObjCClassByNameReference(IRGenModule &IGM, ClassDecl *cls) {
27442746
SmallString<64> objcRuntimeNameBuffer;
27452747
auto ref = IGM.getAddrOfGlobalString(
27462748
cls->getObjCRuntimeName(objcRuntimeNameBuffer),
2747-
/*willByRelativelyAddressed=*/true);
2749+
/*willBeRelativelyAddressed=*/true);
27482750

27492751
return TypeEntityReference(kind, ref);
27502752
}
27512753

27522754
TypeEntityReference
2753-
IRGenModule::getTypeEntityReference(NominalTypeDecl *decl) {
2755+
IRGenModule::getTypeEntityReference(GenericTypeDecl *decl) {
27542756
if (auto protocol = dyn_cast<ProtocolDecl>(decl)) {
27552757
assert(!protocol->isObjC() && "imported protocols not handled here");
27562758
return getProtocolDescriptorEntityReference(*this, protocol);
27572759
}
2758-
2759-
auto clas = dyn_cast<ClassDecl>(decl);
2760-
if (!clas) {
2761-
return getTypeContextDescriptorEntityReference(*this, decl);
2760+
2761+
if (auto opaque = dyn_cast<OpaqueTypeDecl>(decl)) {
2762+
auto entity = LinkEntity::forOpaqueTypeDescriptor(opaque);
2763+
IRGen.noteUseOfOpaqueTypeDescriptor(opaque);
2764+
return getContextDescriptorEntityReference(*this, entity);
27622765
}
27632766

2764-
switch (clas->getForeignClassKind()) {
2765-
case ClassDecl::ForeignKind::RuntimeOnly:
2766-
return getObjCClassByNameReference(*this, clas);
2767+
if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
2768+
auto clas = dyn_cast<ClassDecl>(decl);
2769+
if (!clas) {
2770+
return getTypeContextDescriptorEntityReference(*this, nominal);
2771+
}
27672772

2768-
case ClassDecl::ForeignKind::CFType:
2769-
return getTypeContextDescriptorEntityReference(*this, clas);
2773+
switch (clas->getForeignClassKind()) {
2774+
case ClassDecl::ForeignKind::RuntimeOnly:
2775+
return getObjCClassByNameReference(*this, clas);
27702776

2771-
case ClassDecl::ForeignKind::Normal:
2772-
if (hasKnownSwiftMetadata(*this, clas)) {
2777+
case ClassDecl::ForeignKind::CFType:
27732778
return getTypeContextDescriptorEntityReference(*this, clas);
2774-
}
27752779

2776-
// Note: we would like to use an Objective-C class reference, but the
2777-
// Darwin linker currently has a bug where it will coalesce these symbols
2778-
// *after* computing a relative offset, causing incorrect relative
2779-
// offsets in the metadata. Therefore, reference Objective-C classes by
2780-
// their runtime names.
2781-
return getObjCClassByNameReference(*this, clas);
2780+
case ClassDecl::ForeignKind::Normal:
2781+
if (hasKnownSwiftMetadata(*this, clas)) {
2782+
return getTypeContextDescriptorEntityReference(*this, clas);
2783+
}
2784+
2785+
// Note: we would like to use an Objective-C class reference, but the
2786+
// Darwin linker currently has a bug where it will coalesce these symbols
2787+
// *after* computing a relative offset, causing incorrect relative
2788+
// offsets in the metadata. Therefore, reference Objective-C classes by
2789+
// their runtime names.
2790+
return getObjCClassByNameReference(*this, clas);
2791+
}
27822792
}
27832793
llvm_unreachable("bad foreign type kind");
27842794
}

0 commit comments

Comments
 (0)