diff --git a/include/swift/SIL/SILModule.h b/include/swift/SIL/SILModule.h
index 6362909..fcb0c91 100644
--- a/include/swift/SIL/SILModule.h
+++ b/include/swift/SIL/SILModule.h
@@ -708,6 +708,11 @@
   bool isDefaultAtomic() const {
     return ! getOptions().AssumeSingleThreaded;
   }
+  
+  /// Returns true if SIL entities associated with declarations in the given
+  /// declaration context ought to be serialized as part of this module.
+  bool shouldSerializeEntitiesAssociatedWithDeclContext(const DeclContext *DC)
+    const;
 };
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SILModule &M){
diff --git a/lib/SIL/Linker.cpp b/lib/SIL/Linker.cpp
index dd18be3..e2d36f8 100644
--- a/lib/SIL/Linker.cpp
+++ b/lib/SIL/Linker.cpp
@@ -18,6 +18,8 @@
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/SubstitutionMap.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/FormalLinkage.h"
 #include <functional>
 
@@ -111,10 +113,18 @@
 //===----------------------------------------------------------------------===//
 
 bool SILLinkerVisitor::visitApplyInst(ApplyInst *AI) {
+  bool performFuncDeserialization = false;
+  
+  if (auto sig = AI->getCallee()->getType().castTo<SILFunctionType>()
+                   ->getGenericSignature()) {
+    performFuncDeserialization |= visitApplySubstitutions(
+      sig->getSubstitutionMap(AI->getSubstitutions()));
+  }
+  
   // Ok we have a function ref inst, grab the callee.
   SILFunction *Callee = AI->getReferencedFunction();
   if (!Callee)
-    return false;
+    return performFuncDeserialization;
 
   if (isLinkAll() ||
       hasSharedVisibility(Callee->getLinkage())) {
@@ -122,13 +132,21 @@
     return true;
   }
 
-  return false;
+  return performFuncDeserialization;
 }
 
 bool SILLinkerVisitor::visitPartialApplyInst(PartialApplyInst *PAI) {
+  bool performFuncDeserialization = false;
+  
+  if (auto sig = PAI->getCallee()->getType().castTo<SILFunctionType>()
+                    ->getGenericSignature()) {
+    performFuncDeserialization |= visitApplySubstitutions(
+      sig->getSubstitutionMap(PAI->getSubstitutions()));
+  }
+
   SILFunction *Callee = PAI->getReferencedFunction();
   if (!Callee)
-    return false;
+    return performFuncDeserialization;
 
   if (isLinkAll() ||
       hasSharedVisibility(Callee->getLinkage())) {
@@ -136,7 +154,7 @@
     return true;
   }
 
-  return false;
+  return performFuncDeserialization;
 }
 
 bool SILLinkerVisitor::visitFunctionRefInst(FunctionRefInst *FRI) {
@@ -154,15 +172,36 @@
   return false;
 }
 
+// Eagerly visiting all used conformances leads to a large blowup
+// in the amount of SIL we read in. For optimization purposes we can defer
+// reading in most conformances until we need them for devirtualization.
+// However, we *must* pull in shared clang-importer-derived conformances
+// we potentially use, since we may not otherwise have a local definition.
+static bool mustDeserializeProtocolConformance(SILModule &M,
+                                               ProtocolConformanceRef c) {
+  if (!c.isConcrete())
+    return false;
+  auto conformance = c.getConcrete()->getRootNormalConformance();
+  return M.Types.protocolRequiresWitnessTable(conformance->getProtocol())
+    && isa<ClangModuleUnit>(conformance->getDeclContext()
+                                       ->getModuleScopeContext());
+}
+
 bool SILLinkerVisitor::visitProtocolConformance(
     ProtocolConformanceRef ref, const Optional<SILDeclRef> &Member) {
   // If an abstract protocol conformance was passed in, just return false.
   if (ref.isAbstract())
     return false;
+  
+  bool mustDeserialize = mustDeserializeProtocolConformance(Mod, ref);
 
   // Otherwise try and lookup a witness table for C.
   auto C = ref.getConcrete();
-  SILWitnessTable *WT = Mod.lookUpWitnessTable(C);
+  
+  if (!VisitedConformances.insert(C).second)
+    return false;
+  
+  SILWitnessTable *WT = Mod.lookUpWitnessTable(C, true);
 
   // If we don't find any witness table for the conformance, bail and return
   // false.
@@ -170,7 +209,16 @@
     Mod.createWitnessTableDeclaration(
         C, getLinkageForProtocolConformance(
                C->getRootNormalConformance(), NotForDefinition));
-    return false;
+
+    // Adding the declaration may allow us to now deserialize the body.
+    // Force the body if we must deserialize this witness table.
+    if (mustDeserialize) {
+      WT = Mod.lookUpWitnessTable(C, true);
+      assert(WT && WT->isDefinition()
+             && "unable to deserialize witness table when we must?!");
+    } else {
+      return false;
+    }
   }
 
   // If the looked up witness table is a declaration, there is nothing we can
@@ -179,10 +227,23 @@
     return false;
 
   bool performFuncDeserialization = false;
+  
+  auto maybeVisitRelatedConformance = [&](ProtocolConformanceRef c) {
+    // Formally all conformances referenced by a used conformance are used.
+    // However, eagerly visiting them all at this point leads to a large blowup
+    // in the amount of SIL we read in. For optimization purposes we can defer
+    // reading in most conformances until we need them for devirtualization.
+    // However, we *must* pull in shared clang-importer-derived conformances
+    // we potentially use, since we may not otherwise have a local definition.
+    if (mustDeserializeProtocolConformance(Mod, c))
+      performFuncDeserialization |= visitProtocolConformance(c, None);
+  };
+  
   // For each entry in the witness table...
   for (auto &E : WT->getEntries()) {
+    switch (E.getKind()) {
     // If the entry is a witness method...
-    if (E.getKind() == SILWitnessTable::WitnessKind::Method) {
+    case SILWitnessTable::WitnessKind::Method: {
       // And we are only interested in deserializing a specific requirement
       // and don't have that requirement, don't deserialize this method.
       if (Member.hasValue() && E.getMethodWitness().Requirement != *Member)
@@ -197,12 +258,65 @@
       // to deserialize.
       performFuncDeserialization = true;
       addFunctionToWorklist(E.getMethodWitness().Witness);
+      break;
+    }
+    
+    // If the entry is a related witness table, see whether we need to
+    // eagerly deserialize it.
+    case SILWitnessTable::WitnessKind::BaseProtocol: {
+      auto baseConformance = E.getBaseProtocolWitness().Witness;
+      maybeVisitRelatedConformance(ProtocolConformanceRef(baseConformance));
+      break;
+    }
+    case SILWitnessTable::WitnessKind::AssociatedTypeProtocol: {
+      auto assocConformance = E.getAssociatedTypeProtocolWitness().Witness;
+      maybeVisitRelatedConformance(assocConformance);
+      break;
+    }
+    
+    case SILWitnessTable::WitnessKind::AssociatedType:
+    case SILWitnessTable::WitnessKind::Invalid:
+      break;
     }
   }
 
   return performFuncDeserialization;
 }
 
+bool SILLinkerVisitor::visitApplySubstitutions(const SubstitutionMap &subs) {
+  bool performFuncDeserialization = false;
+  
+  for (auto &reqt : subs.getGenericSignature()->getRequirements()) {
+    switch (reqt.getKind()) {
+    case RequirementKind::Conformance: {
+      auto conformance = subs.lookupConformance(
+          reqt.getFirstType()->getCanonicalType(),
+          cast<ProtocolDecl>(reqt.getSecondType()->getAnyNominal()))
+        .getValue();
+      
+      // Formally all conformances referenced in a function application are
+      // used. However, eagerly visiting them all at this point leads to a
+      // large blowup in the amount of SIL we read in, and we aren't very
+      // systematic about laziness. For optimization purposes we can defer
+      // reading in most conformances until we need them for devirtualization.
+      // However, we *must* pull in shared clang-importer-derived conformances
+      // we potentially use, since we may not otherwise have a local definition.
+      if (mustDeserializeProtocolConformance(Mod, conformance)) {
+        performFuncDeserialization |=
+                                    visitProtocolConformance(conformance, None);
+      }
+      break;
+    }
+    case RequirementKind::Layout:
+    case RequirementKind::SameType:
+    case RequirementKind::Superclass:
+      break;
+    }
+  }
+  
+  return performFuncDeserialization;
+}
+
 bool SILLinkerVisitor::visitInitExistentialAddrInst(
     InitExistentialAddrInst *IEI) {
   // Link in all protocol conformances that this touches.
diff --git a/lib/SIL/Linker.h b/lib/SIL/Linker.h
index cca5839..8cb5a3a 100644
--- a/lib/SIL/Linker.h
+++ b/lib/SIL/Linker.h
@@ -31,6 +31,9 @@
   /// The SILLoader that this visitor is using to link.
   SerializedSILLoader *Loader;
 
+  /// Break cycles visiting recursive protocol conformances.
+  llvm::DenseSet<ProtocolConformance *> VisitedConformances;
+
   /// Worklist of SILFunctions we are processing.
   llvm::SmallVector<SILFunction *, 128> Worklist;
 
@@ -65,6 +68,7 @@
   bool visitFunctionRefInst(FunctionRefInst *FRI);
   bool visitProtocolConformance(ProtocolConformanceRef C,
                                 const Optional<SILDeclRef> &Member);
+  bool visitApplySubstitutions(const SubstitutionMap &subs);
   bool visitWitnessMethodInst(WitnessMethodInst *WMI) {
     return visitProtocolConformance(WMI->getConformance(), WMI->getMember());
   }
diff --git a/lib/SIL/SILModule.cpp b/lib/SIL/SILModule.cpp
index 40adaf9..4b36e23 100644
--- a/lib/SIL/SILModule.cpp
+++ b/lib/SIL/SILModule.cpp
@@ -22,6 +22,7 @@
 #include "Linker.h"
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SIL/SILValue.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -774,6 +775,23 @@
   }
 }
 
+bool SILModule::
+shouldSerializeEntitiesAssociatedWithDeclContext(const DeclContext *DC) const {
+  // Serialize entities associated with this module's associated context.
+  if (DC->isChildContextOf(getAssociatedContext())) {
+    return true;
+  }
+  
+  // Serialize entities associated with clang modules, since other entities
+  // may depend on them, and someone who deserializes those entities may not
+  // have their own copy.
+  if (isa<ClangModuleUnit>(DC->getModuleScopeContext())) {
+    return true;
+  }
+  
+  return false;
+}
+
 /// Returns true if it is the OnoneSupport module.
 bool SILModule::isOnoneSupportModule() const {
   return getSwiftModule()->getName().str() == SWIFT_ONONE_SUPPORT;
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
index 599b498..896131a 100644
--- a/lib/Serialization/Deserialization.cpp
+++ b/lib/Serialization/Deserialization.cpp
@@ -625,6 +625,8 @@
 
   ASTContext &ctx = getContext();
   DeclContext *dc = getDeclContext(contextID);
+  assert(!isa<ClangModuleUnit>(dc->getModuleScopeContext())
+         && "should not have serialized a conformance from a clang module");
   Type conformingType = dc->getDeclaredInterfaceType();
   PrettyStackTraceType trace(ctx, "reading conformance for", conformingType);
 
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
index fb3cb8e..915bb6e 100644
--- a/lib/Serialization/DeserializeSIL.cpp
+++ b/lib/Serialization/DeserializeSIL.cpp
@@ -2814,6 +2814,14 @@
     if (Callback)
       Callback->didDeserialize(MF->getAssociatedModule(), wT);
   }
+  
+  // We may see multiple shared-linkage definitions of the same witness table
+  // for the same conformance.
+  if (wT->isDefinition() && hasSharedVisibility(*Linkage)
+      && hasSharedVisibility(wT->getLinkage())) {
+    wTableOrOffset.set(wT, /*fully deserialized*/ true);
+    return wT;
+  }
 
   assert(wT->isDeclaration() && "Our witness table at this point must be a "
                                 "declaration.");
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
index fa7b05b..8162e22 100644
--- a/lib/Serialization/Serialization.cpp
+++ b/lib/Serialization/Serialization.cpp
@@ -1608,7 +1608,9 @@
   switch (conformance->getKind()) {
   case ProtocolConformanceKind::Normal: {
     auto normal = cast<NormalProtocolConformance>(conformance);
-    if (!isDeclXRef(getDeclForContext(normal->getDeclContext()))) {
+    if (!isDeclXRef(getDeclForContext(normal->getDeclContext()))
+        && !isa<ClangModuleUnit>(normal->getDeclContext()
+                                       ->getModuleScopeContext())) {
       // A normal conformance in this module file.
       unsigned abbrCode = abbrCodes[NormalProtocolConformanceIdLayout::Code];
       NormalProtocolConformanceIdLayout::emitRecord(Out, ScratchRecord,
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
index 5debc36..5c670b8 100644
--- a/lib/Serialization/SerializeSIL.cpp
+++ b/lib/Serialization/SerializeSIL.cpp
@@ -2454,21 +2454,23 @@
   assert(assocDC && "cannot serialize SIL without an associated DeclContext");
   for (const SILVTable &vt : SILMod->getVTables()) {
     if ((ShouldSerializeAll || vt.isSerialized()) &&
-        vt.getClass()->isChildContextOf(assocDC))
+        SILMod->shouldSerializeEntitiesAssociatedWithDeclContext(vt.getClass()))
       writeSILVTable(vt);
   }
   
   // Write out property descriptors.
   for (const SILProperty &prop : SILMod->getPropertyList()) {
     if ((ShouldSerializeAll || prop.isSerialized()) &&
-        prop.getDecl()->getInnermostDeclContext()->isChildContextOf(assocDC))
+        SILMod->shouldSerializeEntitiesAssociatedWithDeclContext(
+                                     prop.getDecl()->getInnermostDeclContext()))
       writeSILProperty(prop);
   }
 
   // Write out fragile WitnessTables.
   for (const SILWitnessTable &wt : SILMod->getWitnessTables()) {
     if ((ShouldSerializeAll || wt.isSerialized()) &&
-        wt.getConformance()->getDeclContext()->isChildContextOf(assocDC))
+        SILMod->shouldSerializeEntitiesAssociatedWithDeclContext(
+                                         wt.getConformance()->getDeclContext()))
       writeSILWitnessTable(wt);
   }
 
@@ -2476,7 +2478,8 @@
   for (const SILDefaultWitnessTable &wt : SILMod->getDefaultWitnessTables()) {
     // FIXME: Don't need to serialize private and internal default witness
     // tables.
-    if (wt.getProtocol()->getDeclContext()->isChildContextOf(assocDC))
+    if (SILMod->shouldSerializeEntitiesAssociatedWithDeclContext(
+                                                              wt.getProtocol()))
       writeSILDefaultWitnessTable(wt);
   }
 
diff --git a/test/IRGen/Inputs/deserialize-clang-importer-witness-tables/regex.swift b/test/IRGen/Inputs/deserialize-clang-importer-witness-tables/regex.swift
new file mode 100644
index 0000000..ce8c929
--- /dev/null
+++ b/test/IRGen/Inputs/deserialize-clang-importer-witness-tables/regex.swift
@@ -0,0 +1,25 @@
+
+import Foundation
+
+public struct RegEx {
+    public let pattern: String
+    fileprivate let regex: NSRegularExpression
+    public typealias Options = NSRegularExpression.Options
+    
+    public init(pattern: String, options: Options = []) throws {
+        self.pattern = pattern
+        self.regex = try NSRegularExpression(pattern: pattern, options: options)
+    }
+    
+    /// Returns a match group for the first match, or nil if there was no match.
+    public func firstMatch(in string: String) -> [String]? {
+        let nsString = string as NSString
+        
+        return regex.firstMatch(in: string, range: NSMakeRange(0, nsString.length)).map { match -> [String] in
+            return (1 ..< match.numberOfRanges).map { idx -> String in
+                let range = match.range(at: idx)
+                return range.location == NSNotFound ? "" : nsString.substring(with: range)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/IRGen/deserialize-clang-importer-witness-tables.swift b/test/IRGen/deserialize-clang-importer-witness-tables.swift
new file mode 100644
index 0000000..9e66fbc
--- /dev/null
+++ b/test/IRGen/deserialize-clang-importer-witness-tables.swift
@@ -0,0 +1,16 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -swift-version 4 -emit-module -o %t/regex.swiftmodule %S/Inputs/deserialize-clang-importer-witness-tables/regex.swift
+// RUN: %target-swift-frontend -swift-version 4 -emit-ir %s -I %t | %FileCheck %s
+// REQUIRES: objc_interop
+import regex
+
+public func foo(line: String) {
+  // The NSRegularExpressionOptions: SetAlgebra conformance is used indirectly
+  // from the default argument expression passed to `RegEx(pattern:options:)`
+  // below. Ensure that a local copy of the definition was deserialized
+  // and lowered to IR.
+  // CHECK-LABEL: define {{.*}} i8** @"$SSo26NSRegularExpressionOptionsVs10SetAlgebraSCWa"
+  // CHECK-LABEL: define {{.*}} void @"$SSo26NSRegularExpressionOptionsVs10SetAlgebraSCsACPxycfCTW"
+  let versionRegex = try! RegEx(pattern: "Apple")
+  _ = versionRegex.firstMatch(in: line)  
+}
\ No newline at end of file
diff --git a/test/SIL/Serialization/Inputs/clang_conformances.sil b/test/SIL/Serialization/Inputs/clang_conformances.sil
index 98453cf..bd4ff2a 100644
--- a/test/SIL/Serialization/Inputs/clang_conformances.sil
+++ b/test/SIL/Serialization/Inputs/clang_conformances.sil
@@ -20,3 +20,11 @@
   dealloc_stack %1 : $*ComparisonResult // id: %9
   return %7 : $Bool                               // id: %10
 }
+
+sil @compare_eq : $@convention(witness_method: Equatable) (@in_guaranteed ComparisonResult, @in_guaranteed ComparisonResult, @thick ComparisonResult.Type) -> Bool
+
+sil_witness_table shared [serialized] ComparisonResult: Equatable module __ObjC {
+  method #Equatable."=="!1: @compare_eq
+}
+
+