Merge pull request #24781 from aschwaighofer/fix_some_type_dynamic_replacement

aschwaighofer · web-flow · commit b127aac1ce32 · 2019-05-23T16:36:32.000-07:00
Fix dynamic replacement of some type when used with associated types
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -1316,6 +1316,25 @@ static std::string getDynamicReplacementSection(IRGenModule &IGM) {
   return sectionName;
 }
 
+static std::string getDynamicReplacementSomeSection(IRGenModule &IGM) {
+  std::string sectionName;
+  switch (IGM.TargetInfo.OutputObjectFormat) {
+  case llvm::Triple::UnknownObjectFormat:
+    llvm_unreachable("Don't know how to emit field records table for "
+                     "the selected object format.");
+  case llvm::Triple::MachO:
+    sectionName = "__TEXT, __swift5_replac2, regular, no_dead_strip";
+    break;
+  case llvm::Triple::ELF:
+  case llvm::Triple::Wasm:
+    sectionName = "swift5_replac2";
+    break;
+  case llvm::Triple::COFF:
+    sectionName = ".sw5reps$B";
+    break;
+  }
+  return sectionName;
+}
 llvm::GlobalVariable *IRGenModule::getGlobalForDynamicallyReplaceableThunk(
     LinkEntity &entity, llvm::Type *type, ForDefinition_t forDefinition) {
   return cast<llvm::GlobalVariable>(
@@ -1469,6 +1488,41 @@ void IRGenerator::emitDynamicReplacements() {
       /*isConstant*/ true, llvm::GlobalValue::PrivateLinkage);
   autoReplVar->setSection(getDynamicReplacementSection(IGM));
   IGM.addUsedGlobal(autoReplVar);
+
+  if (origFuncTypes.empty())
+    return;
+  // Emit records for replacing opaque type descriptor for some types.
+  // struct AutomaticReplacementsSome {
+  //   uint32t flags; // unused
+  //   uint32t numReplacements;
+  //   struct Entry {
+  //     RelativeIndirectablePointer<OpaqueTypeDescriptor*> orig;
+  //     RelativeDirectPointer<OpaqueTypeDescriptor*> replacement;
+  //     uint32_t flags; // unused.
+  //   }[numEntries]
+  // };
+  auto autoReplacementsSome = builder.beginStruct();
+  autoReplacementsSome.addInt32(0); // unused flags.
+  autoReplacementsSome.addInt32(
+      origFuncTypes.size()); // number of replacement entries.
+  auto someReplacementsArray = autoReplacementsSome.beginArray();
+  for (auto i : indices(origFuncTypes)) {
+    auto origDesc =
+        LinkEntity::forOpaqueTypeDescriptor(origFuncTypes[i]->getDecl());
+    auto replDesc =
+        LinkEntity::forOpaqueTypeDescriptor(newFuncTypes[i]->getDecl());
+    auto replacement = someReplacementsArray.beginStruct();
+    replacement.addRelativeAddress(
+        IGM.getAddrOfLLVMVariableOrGOTEquivalent(origDesc));
+    replacement.addRelativeAddress(
+        IGM.getAddrOfLLVMVariableOrGOTEquivalent(replDesc));
+    replacement.finishAndAddTo(someReplacementsArray);
+  }
+  someReplacementsArray.finishAndAddTo(autoReplacementsSome);
+  auto autoReplVar2 = autoReplacementsSome.finishAndCreateGlobal(
+      "\x01l_auto_dynamic_replacements_some", IGM.getPointerAlignment(),
+      /*isConstant*/ true, llvm::GlobalValue::PrivateLinkage);
+  autoReplVar2->setSection(getDynamicReplacementSomeSection(IGM));
 }
 
 void IRGenerator::emitEagerClassInitialization() {
diff --git a/stdlib/public/runtime/ImageInspection.h b/stdlib/public/runtime/ImageInspection.h
@@ -80,7 +80,9 @@ void addImageProtocolConformanceBlockCallback(const void *start,
                                               uintptr_t size);
 void addImageTypeMetadataRecordBlockCallback(const void *start,
                                              uintptr_t size);
-void addImageDynamicReplacementBlockCallback(const void *start, uintptr_t size);
+void addImageDynamicReplacementBlockCallback(const void *start, uintptr_t size,
+                                             const void *start2,
+                                             uintptr_t size2);
 
 int lookupSymbol(const void *address, SymbolInfo *info);
 void *lookupSection(const char *segment, const char *section, size_t *outSize);
diff --git a/stdlib/public/runtime/ImageInspectionCOFF.cpp b/stdlib/public/runtime/ImageInspectionCOFF.cpp
@@ -118,9 +118,14 @@ void swift_addNewDSOImage(const void *addr) {
   const auto &dynamic_replacements = sections->swift5_repl;
   const auto *replacements =
       reinterpret_cast<void *>(dynamic_replacements.start);
-  if (dynamic_replacements.length)
-    addImageDynamicReplacementBlockCallback(replacements, dynamic_replacements.length);
-
+  if (dynamic_replacements.length) {
+    const auto &dynamic_replacements_some = sections->swift5_reps;
+    const auto *replacements_some =
+      reinterpret_cast<void *>(dynamic_replacements_some.start);
+    addImageDynamicReplacementBlockCallback(
+        replacements, dynamic_replacements.length, replacements_some,
+        dynamic_replacements_some.length);
+  }
 }
 
 int swift::lookupSymbol(const void *address, SymbolInfo *info) {
diff --git a/stdlib/public/runtime/ImageInspectionCOFF.h b/stdlib/public/runtime/ImageInspectionCOFF.h
@@ -53,6 +53,7 @@ struct MetadataSections {
   Range swift5_fieldmd;
   Range swift5_assocty;
   Range swift5_repl;
+  Range swift5_reps;
 };
 } // namespace swift
 
diff --git a/stdlib/public/runtime/ImageInspectionELF.cpp b/stdlib/public/runtime/ImageInspectionELF.cpp
@@ -121,9 +121,14 @@ void swift_addNewDSOImage(const void *addr) {
   const auto &dynamic_replacements = sections->swift5_replace;
   const auto *replacements =
       reinterpret_cast<void *>(dynamic_replacements.start);
-  if (dynamic_replacements.length)
-    addImageDynamicReplacementBlockCallback(replacements,
-                                            dynamic_replacements.length);
+  if (dynamic_replacements.length) {
+    const auto &dynamic_replacements_some = sections->swift5_replac2;
+    const auto *replacements_some =
+      reinterpret_cast<void *>(dynamic_replacements_some.start);
+    addImageDynamicReplacementBlockCallback(
+        replacements, dynamic_replacements.length, replacements_some,
+        dynamic_replacements_some.length);
+  }
 }
 
 int swift::lookupSymbol(const void *address, SymbolInfo *info) {
diff --git a/stdlib/public/runtime/ImageInspectionELF.h b/stdlib/public/runtime/ImageInspectionELF.h
@@ -53,6 +53,7 @@ struct MetadataSections {
   Range swift5_fieldmd;
   Range swift5_assocty;
   Range swift5_replace;
+  Range swift5_replac2;
 };
 } // namespace swift
 
diff --git a/stdlib/public/runtime/ImageInspectionMachO.cpp b/stdlib/public/runtime/ImageInspectionMachO.cpp
@@ -41,6 +41,7 @@ constexpr const char TypeMetadataRecordSection[] = "__swift5_types";
 /// The Mach-O section name for the section containing dynamic replacements.
 /// This lives within SEG_TEXT.
 constexpr const char DynamicReplacementSection[] = "__swift5_replace";
+constexpr const char DynamicReplacementSomeSection[] = "__swift5_replac2";
 
 constexpr const char TextSegment[] = SEG_TEXT;
 
@@ -72,6 +73,36 @@ void addImageCallback(const mach_header *mh, intptr_t vmaddr_slide) {
   CONSUME_BLOCK(section, size);
 }
 
+template <const char *SEGMENT_NAME, const char *SECTION_NAME,
+          const char *SEGMENT_NAME2, const char *SECTION_NAME2,
+          void CONSUME_BLOCK(const void *start, uintptr_t size,
+                             const void *start2, uintptr_t size2)>
+void addImageCallback2Sections(const mach_header *mh, intptr_t vmaddr_slide) {
+#if __POINTER_WIDTH__ == 64
+  assert(mh->magic == MH_MAGIC_64 && "loaded non-64-bit image?!");
+#endif
+
+  // Look for a section.
+  unsigned long size;
+  const uint8_t *section =
+  getsectiondata(reinterpret_cast<const mach_header_platform *>(mh),
+                 SEGMENT_NAME, SECTION_NAME,
+                 &size);
+
+  if (!section)
+    return;
+
+  // Look for another section.
+  unsigned long size2;
+  const uint8_t *section2 =
+  getsectiondata(reinterpret_cast<const mach_header_platform *>(mh),
+                 SEGMENT_NAME2, SECTION_NAME2,
+                 &size2);
+  if (!section2)
+    size2 = 0;
+
+  CONSUME_BLOCK(section, size, section2, size2);
+}
 } // end anonymous namespace
 
 void swift::initializeProtocolLookup() {
@@ -93,8 +124,9 @@ void swift::initializeTypeMetadataRecordLookup() {
 
 void swift::initializeDynamicReplacementLookup() {
   _dyld_register_func_for_add_image(
-      addImageCallback<TextSegment, DynamicReplacementSection,
-                       addImageDynamicReplacementBlockCallback>);
+      addImageCallback2Sections<TextSegment, DynamicReplacementSection,
+                                TextSegment, DynamicReplacementSomeSection,
+                                addImageDynamicReplacementBlockCallback>);
 }
 
 int swift::lookupSymbol(const void *address, SymbolInfo *info) {
diff --git a/stdlib/public/runtime/MetadataLookup.cpp b/stdlib/public/runtime/MetadataLookup.cpp
@@ -1028,14 +1028,47 @@ Optional<const ProtocolRequirement *> findAssociatedTypeByName(
   swift_runtime_unreachable("associated type names don't line up");
 }
 
+namespace {
+  static Lazy<Mutex> DynamicReplacementLock;
+}
+
+namespace {
+struct OpaqueTypeMappings {
+  llvm::DenseMap<const OpaqueTypeDescriptor *, const OpaqueTypeDescriptor *>
+      descriptorMapping;
+  const OpaqueTypeDescriptor* find(const OpaqueTypeDescriptor *orig) {
+    const OpaqueTypeDescriptor *replacement = nullptr;
+    DynamicReplacementLock.get().withLock([&] {
+      auto entry = descriptorMapping.find(orig);
+      if (entry != descriptorMapping.end())
+        replacement = entry->second;
+    });
+    return replacement;
+  }
+
+  // We take a mutex argument to make sure someone is holding the lock.
+  void insert(const OpaqueTypeDescriptor *orig,
+              const OpaqueTypeDescriptor *replacement, const Mutex &) {
+    descriptorMapping[orig] = replacement;
+  }
+};
+} // end unnamed namespace
+
+static Lazy<OpaqueTypeMappings> opaqueTypeMappings;
+
+
 static const OpaqueTypeDescriptor *
 _findOpaqueTypeDescriptor(NodePointer demangleNode,
                           Demangler &dem) {
   // Directly resolve a symbolic reference.
   if (demangleNode->getKind()
         == Node::Kind::OpaqueTypeDescriptorSymbolicReference) {
     auto context = (const ContextDescriptor *)demangleNode->getIndex();
-    return cast<OpaqueTypeDescriptor>(context);
+    auto *orig = cast<OpaqueTypeDescriptor>(context);
+    if (auto *entry = opaqueTypeMappings.get().find(orig)) {
+      return entry;
+    }
+    return orig;
   }
   
   // TODO: Find non-symbolic-referenced opaque decls.
@@ -1976,6 +2009,7 @@ void DynamicReplacementDescriptor::disableReplacement() const {
 }
 
 /// An automatic dymamic replacement entry.
+namespace {
 class AutomaticDynamicReplacementEntry {
   RelativeDirectPointer<DynamicReplacementScope, false> replacementScope;
   uint32_t flags;
@@ -2012,16 +2046,64 @@ class AutomaticDynamicReplacements
   }
 };
 
-namespace {
-  static Lazy<Mutex> DynamicReplacementLock;
-}
+/// A map from original to replaced opaque type descriptor of a some type.
+class DynamicReplacementSomeDescriptor {
+  RelativeIndirectablePointer<const OpaqueTypeDescriptor, false>
+      originalOpaqueTypeDesc;
+  RelativeDirectPointer<const OpaqueTypeDescriptor, false>
+      replacementOpaqueTypeDesc;
+
+public:
+  void enable(const Mutex &lock) const {
+    opaqueTypeMappings.get().insert(originalOpaqueTypeDesc.get(),
+                                    replacementOpaqueTypeDesc.get(), lock);
+  }
+};
+
+/// A list of dynamic replacements of some types.
+class AutomaticDynamicReplacementsSome
+    : private swift::ABI::TrailingObjects<AutomaticDynamicReplacementsSome,
+                                          DynamicReplacementSomeDescriptor> {
+  uint32_t flags;
+  uint32_t numEntries;
+  using TrailingObjects =
+      swift::ABI::TrailingObjects<AutomaticDynamicReplacementsSome,
+                                  DynamicReplacementSomeDescriptor>;
+  friend TrailingObjects;
+
+
+  ArrayRef<DynamicReplacementSomeDescriptor> getReplacementEntries() const {
+    return {
+        this->template getTrailingObjects<DynamicReplacementSomeDescriptor>(),
+        numEntries};
+  }
+
+public:
+  void enableReplacements(const Mutex &lock) const {
+    for (auto &replacementEntry : getReplacementEntries())
+      replacementEntry.enable(lock);
+  }
+};
+
+} // anonymous namespace
 
 void swift::addImageDynamicReplacementBlockCallback(
-    const void *replacements, uintptr_t replacementsSize) {
+    const void *replacements, uintptr_t replacementsSize,
+    const void *replacementsSome, uintptr_t replacementsSomeSize) {
   auto *automaticReplacements =
       reinterpret_cast<const AutomaticDynamicReplacements *>(replacements);
-  DynamicReplacementLock.get().withLock(
-      [&] { automaticReplacements->enableReplacements(); });
+  const AutomaticDynamicReplacementsSome *someReplacements = nullptr;
+  if (replacementsSomeSize) {
+    someReplacements =
+        reinterpret_cast<const AutomaticDynamicReplacementsSome *>(
+            replacementsSome);
+  }
+  auto &lock = DynamicReplacementLock.get();
+  lock.withLock([&] {
+    automaticReplacements->enableReplacements();
+    if (someReplacements)
+      someReplacements->enableReplacements(lock);
+  });
 }
 
 void swift::swift_enableDynamicReplacementScope(
diff --git a/stdlib/public/runtime/SwiftRT-COFF.cpp b/stdlib/public/runtime/SwiftRT-COFF.cpp
@@ -45,6 +45,7 @@ DECLARE_SWIFT_SECTION(sw5rfst)
 DECLARE_SWIFT_SECTION(sw5flmd)
 DECLARE_SWIFT_SECTION(sw5asty)
 DECLARE_SWIFT_SECTION(sw5repl)
+DECLARE_SWIFT_SECTION(sw5reps)
 }
 
 namespace {
@@ -72,6 +73,7 @@ static void swift_image_constructor() {
       SWIFT_SECTION_RANGE(sw5flmd),
       SWIFT_SECTION_RANGE(sw5asty),
       SWIFT_SECTION_RANGE(sw5repl),
+      SWIFT_SECTION_RANGE(sw5reps),
   };
 
 #undef SWIFT_SECTION_RANGE
diff --git a/stdlib/public/runtime/SwiftRT-ELF.cpp b/stdlib/public/runtime/SwiftRT-ELF.cpp
@@ -33,6 +33,7 @@ DECLARE_SWIFT_SECTION(swift5_reflstr)
 DECLARE_SWIFT_SECTION(swift5_fieldmd)
 DECLARE_SWIFT_SECTION(swift5_assocty)
 DECLARE_SWIFT_SECTION(swift5_replace)
+DECLARE_SWIFT_SECTION(swift5_replac2)
 }
 
 #undef DECLARE_SWIFT_SECTION
@@ -63,6 +64,7 @@ static void swift_image_constructor() {
       SWIFT_SECTION_RANGE(swift5_fieldmd),
       SWIFT_SECTION_RANGE(swift5_assocty),
       SWIFT_SECTION_RANGE(swift5_replace),
+      SWIFT_SECTION_RANGE(swift5_replac2),
   };
 
 #undef SWIFT_SECTION_RANGE
diff --git a/test/Interpreter/Inputs/dynamic_replacement_opaque1.swift b/test/Interpreter/Inputs/dynamic_replacement_opaque1.swift
@@ -40,3 +40,22 @@ struct Container {
     }
   }
 }
+
+protocol Q {}
+
+struct NewType : Q {}
+
+extension Int : Q {}
+
+public protocol Assoc {
+  associatedtype A = Int
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  func act() -> A
+}
+
+struct Test : Assoc {
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  func act() -> some Q {
+    return 1
+  }
+}
diff --git a/test/Interpreter/Inputs/dynamic_replacement_opaque2.swift b/test/Interpreter/Inputs/dynamic_replacement_opaque2.swift
@@ -43,3 +43,11 @@ extension Container {
     }
   }
 }
+
+extension Test {
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
+  @_dynamicReplacement(for: act)
+  func act_r() -> some Q {
+    return NewType()
+  }
+}
diff --git a/test/Interpreter/dynamic_replacement_opaque_result.swift b/test/Interpreter/dynamic_replacement_opaque_result.swift
diff --git a/test/Interpreter/dynamic_replacement_opaque_result2.swift b/test/Interpreter/dynamic_replacement_opaque_result2.swift
diff --git a/test/Reflection/box_descriptors.sil b/test/Reflection/box_descriptors.sil

Original file line number	Diff line number	Diff line change
`@@ -43,3 +43,11 @@ extension Container {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`}`
	`46`	`+`
	`47`	`+extension Test {`
	`48`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
	`49`	`+ @_dynamicReplacement(for: act)`
	`50`	`+ func act_r() -> some Q {`
	`51`	`+ return NewType()`
	`52`	`+ }`
	`53`	`+}`