@@ -509,8 +509,8 @@ class MetadataReader {
509
509
// The symbolic reference points at a non-unique extended
510
510
// existential type shape.
511
511
return dem.createNode (
512
- Node::Kind::NonUniqueExtendedExistentialTypeShapeSymbolicReference,
513
- resolved.getResolvedAddress ().getAddressData ());
512
+ Node::Kind::NonUniqueExtendedExistentialTypeShapeSymbolicReference,
513
+ resolved.getResolvedAddress ().getAddressData ());
514
514
}
515
515
case Demangle::SymbolicReferenceKind::ObjectiveCProtocol: {
516
516
// 'resolved' points to a struct of two relative addresses.
@@ -886,6 +886,77 @@ class MetadataReader {
886
886
return resolver.swiftProtocol (Demangled);
887
887
}
888
888
889
+ BuiltType readTypeFromShape (
890
+ RemoteAbsolutePointer shapeAddress, bool non_unique,
891
+ std::function<std::optional<std::vector<BuiltType>>(unsigned )> getArgs) {
892
+ StoredPointer addr = shapeAddress.getResolvedAddress ().getAddressData ();
893
+ // Non-unique shapes start with an offset to a cache variable.
894
+ if (non_unique)
895
+ addr += 4 ;
896
+ ShapeRef Shape = readShape (addr);
897
+ if (!Shape)
898
+ return BuiltType ();
899
+
900
+ assert (Shape->hasGeneralizationSignature ());
901
+ auto builtArgs = getArgs (Shape->getGenSigArgumentLayoutSizeInWords ());
902
+
903
+ // Pull out the existential type from the mangled type name.
904
+ Demangler dem;
905
+ auto mangledExistentialAddr =
906
+ resolveRelativeField (Shape, Shape->ExistentialType );
907
+ auto node = readMangledName (RemoteAddress (mangledExistentialAddr),
908
+ MangledNameKind::Type, dem);
909
+ if (!node)
910
+ return BuiltType ();
911
+
912
+ BuiltType builtProto = decodeMangledType (node).getType ();
913
+ if (!builtProto)
914
+ return BuiltType ();
915
+
916
+ if (builtArgs) {
917
+ // Build up a substitution map for the generalized signature.
918
+ BuiltGenericSignature sig =
919
+ decodeRuntimeGenericSignature (Shape,
920
+ Shape->getGeneralizationSignature ())
921
+ .getType ();
922
+ if (!sig)
923
+ return BuiltType ();
924
+
925
+ BuiltSubstitutionMap subst =
926
+ Builder.createSubstitutionMap (sig, *builtArgs);
927
+ if (subst.empty ())
928
+ return BuiltType ();
929
+
930
+ builtProto = Builder.subst (builtProto, subst);
931
+ if (!builtProto)
932
+ return BuiltType ();
933
+ }
934
+
935
+ // Read the type expression to build up any remaining layers of
936
+ // existential metatype.
937
+ if (Shape->Flags .hasTypeExpression ()) {
938
+ Demangler dem;
939
+
940
+ // Read the mangled name.
941
+ auto mangledContextName = Shape->getTypeExpression ();
942
+ auto mangledNameAddress =
943
+ resolveRelativeField (Shape, mangledContextName->name );
944
+ auto node = readMangledName (RemoteAddress (mangledNameAddress),
945
+ MangledNameKind::Type, dem);
946
+ if (!node)
947
+ return BuiltType ();
948
+
949
+ while (node->getKind () == Demangle::Node::Kind::Type &&
950
+ node->getNumChildren () &&
951
+ node->getChild (0 )->getKind () == Demangle::Node::Kind::Metatype &&
952
+ node->getChild (0 )->getNumChildren ()) {
953
+ builtProto = Builder.createExistentialMetatypeType (builtProto);
954
+ node = node->getChild (0 )->getChild (0 );
955
+ }
956
+ }
957
+ return builtProto;
958
+ }
959
+
889
960
// / Given a remote pointer to metadata, attempt to turn it into a type.
890
961
BuiltType
891
962
readTypeFromMetadata (StoredPointer MetadataAddress,
@@ -1081,79 +1152,27 @@ class MetadataReader {
1081
1152
}
1082
1153
case MetadataKind::ExtendedExistential: {
1083
1154
auto Exist = cast<TargetExtendedExistentialTypeMetadata<Runtime>>(Meta);
1084
-
1085
1155
// Read the shape for this existential.
1086
1156
StoredPointer shapeAddress = stripSignedPointer (Exist->Shape );
1087
- ShapeRef Shape = readShape (shapeAddress);
1088
- if (!Shape)
1089
- return BuiltType ();
1090
-
1091
- const unsigned shapeArgumentCount
1092
- = Shape->getGenSigArgumentLayoutSizeInWords ();
1093
- // Pull out the arguments to the generalization signature.
1094
- assert (Shape->hasGeneralizationSignature ());
1095
- std::vector<BuiltType> builtArgs;
1096
- for (unsigned i = 0 ; i < shapeArgumentCount; ++i) {
1097
- auto remoteArg = Exist->getGeneralizationArguments ()[i];
1098
- auto builtArg = readTypeFromMetadata (remoteArg, false , recursion_limit);
1099
- if (!builtArg)
1100
- return BuiltType ();
1101
- builtArgs.push_back (builtArg);
1102
- }
1103
-
1104
- // Pull out the existential type from the mangled type name.
1105
- Demangler dem;
1106
- auto mangledExistentialAddr =
1107
- resolveRelativeField (Shape, Shape->ExistentialType );
1108
- auto node = readMangledName (RemoteAddress (mangledExistentialAddr),
1109
- MangledNameKind::Type, dem);
1110
- if (!node)
1111
- return BuiltType ();
1112
-
1113
- BuiltType builtProto = decodeMangledType (node).getType ();
1114
- if (!builtProto)
1115
- return BuiltType ();
1116
-
1117
- // Build up a substitution map for the generalized signature.
1118
- BuiltGenericSignature sig =
1119
- decodeRuntimeGenericSignature (Shape,
1120
- Shape->getGeneralizationSignature ())
1121
- .getType ();
1122
- if (!sig)
1123
- return BuiltType ();
1124
-
1125
- BuiltSubstitutionMap subst =
1126
- Builder.createSubstitutionMap (sig, builtArgs);
1127
- if (subst.empty ())
1128
- return BuiltType ();
1129
-
1130
- builtProto = Builder.subst (builtProto, subst);
1131
- if (!builtProto)
1132
- return BuiltType ();
1133
-
1134
- // Read the type expression to build up any remaining layers of
1135
- // existential metatype.
1136
- if (Shape->Flags .hasTypeExpression ()) {
1137
- Demangler dem;
1138
-
1139
- // Read the mangled name.
1140
- auto mangledContextName = Shape->getTypeExpression ();
1141
- auto mangledNameAddress =
1142
- resolveRelativeField (Shape, mangledContextName->name );
1143
- auto node = readMangledName (RemoteAddress (mangledNameAddress),
1144
- MangledNameKind::Type, dem);
1145
- if (!node)
1146
- return BuiltType ();
1147
-
1148
- while (node->getKind () == Demangle::Node::Kind::Type &&
1149
- node->getNumChildren () &&
1150
- node->getChild (0 )->getKind () == Demangle::Node::Kind::Metatype &&
1151
- node->getChild (0 )->getNumChildren ()) {
1152
- builtProto = Builder.createExistentialMetatypeType (builtProto);
1153
- node = node->getChild (0 )->getChild (0 );
1154
- }
1155
- }
1156
1157
1158
+ // FIXME!
1159
+ bool non_unique = false ;
1160
+ auto builtProto = readTypeFromShape (
1161
+ RemoteAddress (shapeAddress), non_unique,
1162
+ [&](unsigned shapeArgumentCount)
1163
+ -> std::optional<std::vector<BuiltType>> {
1164
+ // Pull out the arguments to the generalization signature.
1165
+ std::vector<BuiltType> builtArgs;
1166
+ for (unsigned i = 0 ; i < shapeArgumentCount; ++i) {
1167
+ auto remoteArg = Exist->getGeneralizationArguments ()[i];
1168
+ auto builtArg =
1169
+ readTypeFromMetadata (remoteArg, false , recursion_limit);
1170
+ if (!builtArg)
1171
+ return std::nullopt;
1172
+ builtArgs.push_back (builtArg);
1173
+ }
1174
+ return builtArgs;
1175
+ });
1157
1176
TypeCache[TypeCacheKey] = builtProto;
1158
1177
return builtProto;
1159
1178
}
@@ -1371,8 +1390,7 @@ class MetadataReader {
1371
1390
readContextDescriptor (address.getResolvedAddress ().getAddressData ()));
1372
1391
}
1373
1392
1374
- ShapeRef
1375
- readShape (StoredPointer address) {
1393
+ ShapeRef readShape (StoredPointer address) {
1376
1394
if (address == 0 )
1377
1395
return nullptr ;
1378
1396
@@ -2148,6 +2166,7 @@ class MetadataReader {
2148
2166
return nullptr ;
2149
2167
auto shapePtr = stripSignedPointer (signedShapePtr);
2150
2168
2169
+ // FIXME: Apply non-unique +4 offset?
2151
2170
auto shape = readShape (shapePtr);
2152
2171
if (!shape)
2153
2172
return nullptr ;
0 commit comments