Merge pull request swiftlang#20987 from slavapestov/backward-deployment

Backward deployment fixes and tests

Author: slavapestov

include/swift/ABI/Metadata.h

@@ -845,13 +845,15 @@ struct TargetVTableDescriptorHeader {
 template <typename Runtime>
 struct TargetMethodOverrideDescriptor {
   /// The class containing the base method.
-  TargetRelativeIndirectablePointer<Runtime, TargetClassDescriptor<Runtime>> Class;
+  TargetRelativeIndirectablePointer<Runtime, TargetClassDescriptor<Runtime>,
+                                    /*nullable*/ true> Class;
 
   /// The base method.
-  TargetRelativeIndirectablePointer<Runtime, TargetMethodDescriptor<Runtime>> Method;
+  TargetRelativeIndirectablePointer<Runtime, TargetMethodDescriptor<Runtime>,
+                                    /*nullable*/ true> Method;
 
   /// The implementation of the override.
-  TargetRelativeDirectPointer<Runtime, void, /*Nullable=*/true> Impl;
+  TargetRelativeDirectPointer<Runtime, void, /*nullable*/ true> Impl;
 };
 
 /// Header for a class vtable override descriptor. This is a variable-sized

include/swift/AST/Attr.def

@@ -362,7 +362,7 @@ DECL_ATTR(_clangImporterSynthesizedType, ClangImporterSynthesizedType,
   NotSerialized, 74)
 SIMPLE_DECL_ATTR(_weakLinked, WeakLinked,
   OnNominalType | OnAssociatedType | OnFunc | OnAccessor | OnVar |
-  OnSubscript | OnConstructor | OnEnumElement | UserInaccessible,
+  OnSubscript | OnConstructor | OnEnumElement | OnExtension | UserInaccessible,
   75)
 SIMPLE_DECL_ATTR(_frozen, Frozen,
   OnEnum |

include/swift/AST/ProtocolConformance.h

@@ -356,6 +356,9 @@ class RootProtocolConformance : public ProtocolConformance {
 
   bool isInvalid() const;
 
+  /// Whether this conformance is weak-imported.
+  bool isWeakImported(ModuleDecl *fromModule) const;
+
   bool hasWitness(ValueDecl *requirement) const;
   Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const;
 

lib/AST/Decl.cpp

@@ -557,6 +557,12 @@ bool Decl::isWeakImported(ModuleDecl *fromModule) const {
   if (auto *dtor = dyn_cast<DestructorDecl>(this))
     return cast<ClassDecl>(dtor->getDeclContext())->isWeakImported(fromModule);
 
+  auto *dc = getDeclContext();
+  if (auto *ext = dyn_cast<ExtensionDecl>(dc))
+    return ext->isWeakImported(fromModule);
+  if (auto *ntd = dyn_cast<NominalTypeDecl>(dc))
+    return ntd->isWeakImported(fromModule);
+
   // FIXME: Also check availability when containingModule is resilient.
   return false;
 }

lib/AST/ProtocolConformance.cpp

@@ -394,6 +394,29 @@ SourceLoc RootProtocolConformance::getLoc() const {
   ROOT_CONFORMANCE_SUBCLASS_DISPATCH(getLoc, ())
 }
 
+bool RootProtocolConformance::isWeakImported(ModuleDecl *fromModule) const {
+  auto *dc = getDeclContext();
+  if (dc->getParentModule() == fromModule)
+    return false;
+
+  // If the protocol is weak imported, so are any conformances to it.
+  if (getProtocol()->isWeakImported(fromModule))
+    return true;
+
+  // If the conforming type is weak imported, so are any of its conformances.
+  if (auto *nominal = getType()->getAnyNominal())
+    if (nominal->isWeakImported(fromModule))
+      return true;
+
+  // If the conformance is declared in an extension with the @_weakLinked
+  // attribute, it is weak imported.
+  if (auto *ext = dyn_cast<ExtensionDecl>(dc))
+    if (ext->isWeakImported(fromModule))
+      return true;
+
+  return false;
+}
+
 bool RootProtocolConformance::hasWitness(ValueDecl *requirement) const {
   ROOT_CONFORMANCE_SUBCLASS_DISPATCH(hasWitness, (requirement))
 }

lib/IRGen/Linking.cpp

@@ -917,6 +917,11 @@ bool LinkEntity::isWeakImported(ModuleDecl *module) const {
   case Kind::DynamicallyReplaceableFunctionImpl:
     return getDecl()->isWeakImported(module);
 
+  case Kind::ProtocolWitnessTable:
+  case Kind::ProtocolConformanceDescriptor:
+    return getProtocolConformance()->getRootConformance()
+                                   ->isWeakImported(module);
+
   // TODO: Revisit some of the below, for weak conformances.
   case Kind::TypeMetadataPattern:
   case Kind::TypeMetadataInstantiationCache:
@@ -925,12 +930,10 @@ bool LinkEntity::isWeakImported(ModuleDecl *module) const {
   case Kind::TypeMetadataCompletionFunction:
   case Kind::ExtensionDescriptor:
   case Kind::AnonymousDescriptor:
-  case Kind::ProtocolWitnessTable:
   case Kind::ProtocolWitnessTablePattern:
   case Kind::GenericProtocolWitnessTableInstantiationFunction:
   case Kind::AssociatedTypeWitnessTableAccessFunction:
   case Kind::ReflectionAssociatedTypeDescriptor:
-  case Kind::ProtocolConformanceDescriptor:
   case Kind::ProtocolWitnessTableLazyAccessFunction:
   case Kind::ProtocolWitnessTableLazyCacheVariable:
   case Kind::ValueWitness:

stdlib/public/runtime/Metadata.cpp

@@ -2364,6 +2364,11 @@ static void initClassVTable(ClassMetadata *self) {
       auto *baseClass = descriptor.Class.get();
       auto *baseMethod = descriptor.Method.get();
 
+      // If the base method is null, it's an unavailable weak-linked
+      // symbol.
+      if (baseClass == nullptr || baseMethod == nullptr)
+        continue;
+
       // Calculate the base method's vtable offset from the
       // base method descriptor. The offset will be relative
       // to the base class's vtable start offset.

test/IRGen/Inputs/weak_import_native_helper.swift

@@ -83,7 +83,10 @@ public protocol P {
 }
 
 @_weakLinked
-public struct WeakS {}
+public struct WeakS {
+  public init() {}
+  public func weakMember() {}
+}
 
 @_weakLinked
 public enum WeakE {}
@@ -115,3 +118,6 @@ public protocol ProtocolWithWeakMembers {
 extension ProtocolWithWeakMembers {
   @_weakLinked public func f() {}
 }
+
+public protocol BaseP {}
+@_weakLinked extension S : BaseP {}

test/IRGen/weak_import_native.swift

@@ -55,6 +55,10 @@ func testStruct() {
   let z = s[0]
   s[0] = z
   s[0] += 1
+
+  // CHECK-DAG: declare extern_weak {{.+}} @"$s25weak_import_native_helper5WeakSV0A6MemberyyF"
+  let w = WeakS()
+  w.weakMember()
 }
 
 func testEnum() {
@@ -166,3 +170,8 @@ class WeakGenericSub: GenericC<Int> {
     // CHECK-DAG: declare extern_weak swiftcc {{.+}} @"$s25weak_import_native_helper8GenericCCfd"
   }
 }
+
+protocol RefinesP : BaseP {}
+
+// CHECK-DAG: @"$s25weak_import_native_helper1SVAA5BasePAAWP" = extern_weak global i8*
+extension S : RefinesP {}

utils/rth

@@ -34,7 +34,7 @@ class ResilienceTest(object):
     def __init__(self, target_build_swift, target_run, target_codesign,
                  target_nm, tmp_dir, test_dir, test_src, lib_prefix,
                  lib_suffix, additional_compile_flags,
-                 no_backward_deployment, no_symbol_diff):
+                 backward_deployment, no_symbol_diff):
         self.target_build_swift = shlex.split(target_build_swift)
         self.target_run = shlex.split(target_run)
         self.target_codesign = shlex.split(target_codesign)
@@ -55,7 +55,7 @@ class ResilienceTest(object):
         self.lib_name = self.lib_src_name[:-6]
         self.lib_src = os.path.join(self.test_dir, 'Inputs', self.lib_src_name)
 
-        self.no_backward_deployment = no_backward_deployment
+        self.backward_deployment = backward_deployment
         self.no_symbol_diff = no_symbol_diff
 
     def run(self):
@@ -138,6 +138,12 @@ class ResilienceTest(object):
 
     def compile_main(self):
         for config in self.config_dir_map:
+            # If we're testing backward deployment, we only want to build
+            # the app against the new version of the library.
+            if self.backward_deployment and \
+               config == "BEFORE":
+                continue
+
             output_obj = os.path.join(self.config_dir_map[config], 'main.o')
             compiler_flags = ['-D', config, '-c', self.test_src,
                               '-Xfrontend', '-enable-class-resilience',
@@ -153,11 +159,8 @@ class ResilienceTest(object):
     def configs(self):
         for config1 in self.config_dir_map:
             for config2 in self.config_dir_map:
-                # --no-backward-deployment skips testing a new application
-                # linked against an old library.
-                if config1 == "BEFORE" and \
-                   config2 == "AFTER" and \
-                   self.no_backward_deployment:
+                if self.backward_deployment and \
+                   config2 == "BEFORE":
                     continue
 
                 yield (config1, config2)
@@ -185,6 +188,9 @@ class ResilienceTest(object):
                 '-o', output_obj
             ]
 
+            if self.is_apple_platform():
+                compiler_flags += ['-Xlinker', '-bind_at_load']
+
             command = self.target_build_swift + compiler_flags
             verbose_print_command(command)
             returncode = subprocess.call(command)
@@ -221,7 +227,7 @@ def main():
     parser.add_argument('--lib-prefix', required=True)
     parser.add_argument('--lib-suffix', required=True)
     parser.add_argument('--additional-compile-flags', default='')
-    parser.add_argument('--no-backward-deployment', default=False,
+    parser.add_argument('--backward-deployment', default=False,
                         action='store_true')
     parser.add_argument('--no-symbol-diff', default=False,
                         action='store_true')
@@ -233,7 +239,7 @@ def main():
                                      args.t, args.S, args.s, args.lib_prefix,
                                      args.lib_suffix,
                                      args.additional_compile_flags,
-                                     args.no_backward_deployment,
+                                     args.backward_deployment,
                                      args.no_symbol_diff)
 
     return resilience_test.run()