[pull] swiftwasm from main

include/swift/Remote/MemoryReader.h

@@ -149,19 +149,32 @@ class MemoryReader {
     return RemoteAbsolutePointer("", readValue);
   }
 
-  /// Atempt to resolve the pointer to a symbol for the given remote address.
   virtual llvm::Optional<RemoteAbsolutePointer>
   resolvePointerAsSymbol(RemoteAddress address) {
     return llvm::None;
   }
 
+  /// Lookup a symbol for the given remote address.
+  virtual RemoteAbsolutePointer getSymbol(RemoteAddress address) {
+    if (auto symbol = resolvePointerAsSymbol(address))
+      return *symbol;
+    return RemoteAbsolutePointer("", address.getAddressData());
+  }
+
+  /// Lookup a dynamic symbol name (ie dynamic loader binding) for the given
+  /// remote address. Note: An address can be referenced by both dynamic and
+  /// regular symbols, this function must return a dynamic symbol only.
+  virtual RemoteAbsolutePointer getDynamicSymbol(RemoteAddress address) {
+    return nullptr;
+  }
+
   /// Attempt to read and resolve a pointer value at the given remote address.
   llvm::Optional<RemoteAbsolutePointer> readPointer(RemoteAddress address,
                                                     unsigned pointerSize) {
-    // Try to resolve the pointer as a symbol first, as reading memory
-    // may potentially be expensive.
-    if (auto symbolPointer = resolvePointerAsSymbol(address))
-      return symbolPointer;
+    // First, try to lookup the pointer as a dynamic symbol (binding), as
+    // reading memory may potentially be expensive.
+    if (auto dynamicSymbol = getDynamicSymbol(address))
+      return dynamicSymbol;
 
     auto result = readBytes(address, pointerSize);
     if (!result)

include/swift/Remote/MetadataReader.h

@@ -420,11 +420,7 @@ class MetadataReader {
           return nullptr;
         }
       } else {
-        resolved = Reader->resolvePointer(RemoteAddress(remoteAddress), 0);
-        if (resolved.getSymbol().empty()) {
-          // No symbol found, use the already calculated address.
-          resolved = RemoteAbsolutePointer("", remoteAddress);
-        }
+        resolved = Reader->getSymbol(RemoteAddress(remoteAddress));
       }
 
       switch (kind) {

include/swift/SIL/TypeLowering.h

@@ -1204,6 +1204,39 @@ CanSILFunctionType getNativeSILFunctionType(
     Optional<SubstitutionMap> reqtSubs = None,
     ProtocolConformanceRef witnessMethodConformance = ProtocolConformanceRef());
 
+/// The thunk kinds used in the differentiation transform.
+enum class DifferentiationThunkKind {
+  /// A reabstraction thunk.
+  ///
+  /// Reabstraction thunks transform a function-typed value to another one with
+  /// different parameter/result abstraction patterns. This is identical to the
+  /// thunks generated by SILGen.
+  Reabstraction,
+
+  /// An index subset thunk.
+  ///
+  /// An index subset thunk is used transform JVP/VJPs into a version that is
+  /// "wrt" fewer differentiation parameters.
+  /// - Differentials of thunked JVPs use zero for non-requested differentiation
+  ///    parameters.
+  /// - Pullbacks of thunked VJPs discard results for non-requested
+  ///   differentiation parameters.
+  IndexSubset
+};
+
+/// Build the type of a function transformation thunk.
+CanSILFunctionType buildSILFunctionThunkType(
+    SILFunction *fn,
+    CanSILFunctionType &sourceType,
+    CanSILFunctionType &expectedType,
+    CanType &inputSubstType,
+    CanType &outputSubstType,
+    GenericEnvironment *&genericEnv,
+    SubstitutionMap &interfaceSubs,
+    CanType &dynamicSelfType,
+    bool withoutActuallyEscaping,
+    Optional<DifferentiationThunkKind> differentiationThunkKind = None);
+
 } // namespace swift
 
 namespace llvm {

include/swift/SILOptimizer/Differentiation/Thunk.h

@@ -47,41 +47,6 @@ class ADContext;
 // moved to a shared location.
 //===----------------------------------------------------------------------===//
 
-/// The thunk kinds used in the differentiation transform.
-enum class DifferentiationThunkKind {
-  /// A reabstraction thunk.
-  ///
-  /// Reabstraction thunks transform a function-typed value to another one with
-  /// different parameter/result abstraction patterns. This is identical to the
-  /// thunks generated by SILGen.
-  Reabstraction,
-
-  /// An index subset thunk.
-  ///
-  /// An index subset thunk is used transform JVP/VJPs into a version that is
-  /// "wrt" fewer differentiation parameters.
-  /// - Differentials of thunked JVPs use zero for non-requested differentiation
-  ///    parameters.
-  /// - Pullbacks of thunked VJPs discard results for non-requested
-  ///   differentiation parameters.
-  IndexSubset
-};
-
-CanGenericSignature buildThunkSignature(SILFunction *fn, bool inheritGenericSig,
-                                        OpenedArchetypeType *openedExistential,
-                                        GenericEnvironment *&genericEnv,
-                                        SubstitutionMap &contextSubs,
-                                        SubstitutionMap &interfaceSubs,
-                                        ArchetypeType *&newArchetype);
-
-/// Build the type of a function transformation thunk.
-CanSILFunctionType buildThunkType(SILFunction *fn,
-                                  CanSILFunctionType &sourceType,
-                                  CanSILFunctionType &expectedType,
-                                  GenericEnvironment *&genericEnv,
-                                  SubstitutionMap &interfaceSubs,
-                                  bool withoutActuallyEscaping,
-                                  DifferentiationThunkKind thunkKind);
 
 /// Get or create a reabstraction thunk from `fromType` to `toType`, to be
 /// called in `caller`.

include/swift/StaticMirror/ObjectFileContext.h

@@ -70,6 +70,8 @@ class Image {
 
   remote::RemoteAbsolutePointer resolvePointer(uint64_t Addr,
                                                uint64_t pointerValue) const;
+
+  remote::RemoteAbsolutePointer getDynamicSymbol(uint64_t Addr) const;
 };
 
 /// MemoryReader that reads from the on-disk representation of an executable
@@ -118,6 +120,9 @@ class ObjectMemoryReader : public reflection::MemoryReader {
 
   remote::RemoteAbsolutePointer resolvePointer(reflection::RemoteAddress Addr,
                                                uint64_t pointerValue) override;
+
+  remote::RemoteAbsolutePointer
+  getDynamicSymbol(reflection::RemoteAddress Addr) override;
 };
 
 using ReflectionContextOwner = std::unique_ptr<void, void (*)(void *)>;

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -239,7 +239,8 @@ RequirementMachine::getLongestValidPrefix(const MutableTerm &term) const {
     case Symbol::Kind::Superclass:
     case Symbol::Kind::ConcreteType:
     case Symbol::Kind::ConcreteConformance:
-      llvm_unreachable("Property symbol cannot appear in a type term");
+      llvm::errs() <<"Invalid symbol in a type term: " << term << "\n";
+      abort();
     }
 
     // This symbol is valid, add it to the longest prefix.
@@ -265,6 +266,9 @@ bool RequirementMachine::isCanonicalTypeInContext(Type type) const {
     explicit Walker(const RequirementMachine &self) : Self(self) {}
 
     Action walkToTypePre(Type component) override {
+      if (!component->hasTypeParameter())
+        return Action::SkipChildren;
+
       if (!component->isTypeParameter())
         return Action::Continue;
 
@@ -305,6 +309,9 @@ Type RequirementMachine::getCanonicalTypeInContext(
     TypeArrayView<GenericTypeParamType> genericParams) const {
 
   return type.transformRec([&](Type t) -> Optional<Type> {
+    if (!t->hasTypeParameter())
+      return t;
+
     if (!t->isTypeParameter())
       return None;