diff --git a/docs/SIL.rst b/docs/SIL.rst
index f2d4058ffdc77..412d556aa4fd9 100644
--- a/docs/SIL.rst
+++ b/docs/SIL.rst
@@ -5671,12 +5671,10 @@ differentiable_function_extract
 ::
 
   sil-instruction ::= 'differentiable_function_extract'
-                      sil-differentiable-function-extractee
+                      '[' sil-differentiable-function-extractee ']'
                       sil-value ':' sil-type
 
-  sil-differentiable-function-extractee ::=
-      '[' sil-differentiable-function-extractee ']'
-  sil-differentiable-function-extractee-name ::= 'original' | 'jvp' | 'vjp'
+  sil-differentiable-function-extractee ::= 'original' | 'jvp' | 'vjp'
 
   differentiable_function_extract [original] %0 : $@differentiable (T) -> T
   differentiable_function_extract [jvp] %0 : $@differentiable (T) -> T
@@ -5692,12 +5690,10 @@ linear_function_extract
 ::
 
   sil-instruction ::= 'linear_function_extract'
-                      sil-linear-function-extractee
+                      '[' sil-linear-function-extractee ']'
                       sil-value ':' sil-type
 
-  sil-linear-function-extractee ::=
-      '[' sil-linear-function-extractee ']'
-  sil-linear-function-extractee-name ::= 'original' | 'transpose'
+  sil-linear-function-extractee ::= 'original' | 'transpose'
 
   linear_function_extract [original] %0 : $@differentiable(linear) (T) -> T
   linear_function_extract [transpose] %0 : $@differentiable(linear) (T) -> T
@@ -5707,6 +5703,40 @@ Extracts the original function or a transpose function from the given
 ``[original]`` or ``[transpose]``.
 
 
+differentiability_witness_function
+``````````````````````````````````
+::
+
+  sil-instruction ::=
+      'differentiability_witness_function'
+      '[' sil-differentiability-witness-function-kind ']'
+      '[' 'parameters' sil-differentiability-witness-function-index-list ']'
+      '[' 'results' sil-differentiability-witness-function-index-list ']'
+      generic-parameter-clause?
+      sil-function-name ':' sil-type
+
+  sil-differentiability-witness-function-kind ::= 'jvp' | 'vjp' | 'transpose'
+  sil-differentiability-witness-function-index-list ::= [0-9]+ (' ' [0-9]+)*
+
+  differentiability_witness_function [jvp] [parameters 0] [results 0] \
+    <T where T: Differentiable> @foo : $(T) -> T
+
+Looks up the differentiability witness function for the referenced function
+using SIL differentiability witnesses.
+
+The differentiability witness function kind identifies the witness function to
+look up: ``[jvp]``, ``[vjp]``, or ``[transpose]``.
+
+The remaining components identify the SIL differentiability witness:
+
+- Original function name.
+- Parameter indices.
+- Result indices.
+- Witness generic parameter clause (optional). When parsing SIL, the parsed
+  witness generic parameter clause is combined with the original function's
+  generic signature to form the full witness generic signature.
+
+
 Assertion configuration
 ~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/include/swift/AST/AutoDiff.h b/include/swift/AST/AutoDiff.h
index a4fdca1e4f74a..8d86ed03b8db3 100644
--- a/include/swift/AST/AutoDiff.h
+++ b/include/swift/AST/AutoDiff.h
@@ -79,6 +79,27 @@ struct AutoDiffDerivativeFunctionKind {
   }
 };
 
+/// The kind of a differentiability witness function.
+struct DifferentiabilityWitnessFunctionKind {
+  enum innerty : uint8_t {
+    // The Jacobian-vector products function.
+    JVP = 0,
+    // The vector-Jacobian products function.
+    VJP = 1,
+    // The transpose function.
+    Transpose = 2
+  } rawValue;
+
+  DifferentiabilityWitnessFunctionKind() = default;
+  DifferentiabilityWitnessFunctionKind(innerty rawValue) : rawValue(rawValue) {}
+  explicit DifferentiabilityWitnessFunctionKind(unsigned rawValue)
+      : rawValue(static_cast<innerty>(rawValue)) {}
+  explicit DifferentiabilityWitnessFunctionKind(StringRef name);
+  operator innerty() const { return rawValue; }
+
+  Optional<AutoDiffDerivativeFunctionKind> getAsDerivativeFunctionKind() const;
+};
+
 struct NormalDifferentiableFunctionTypeComponent {
   enum innerty : unsigned {
     Original = 0,
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
index b9fa8a3e44952..e95f93cbd1ee1 100644
--- a/include/swift/AST/DiagnosticsParse.def
+++ b/include/swift/AST/DiagnosticsParse.def
@@ -1620,6 +1620,13 @@ ERROR(sil_inst_autodiff_expected_linear_extractee_kind,PointsToFirstBadToken,
       "and '[transpose]'", ())
 ERROR(sil_inst_autodiff_expected_function_type_operand,PointsToFirstBadToken,
       "expected an operand of a function type", ())
+ERROR(sil_inst_autodiff_expected_differentiability_witness_kind,PointsToFirstBadToken,
+      "expected a differentiability witness kind, which can be one of '[jvp]', "
+      "'[vjp]', or '[transpose]'", ())
+ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
+      "expected witness_generic signature '%0' does not have same generic "
+      "parameters as original function generic signature '%1'",
+      (StringRef, StringRef))
 
 // Quoted attribute.
 ERROR(attr_quoted_enable_experimental_quasiquotes,PointsToFirstBadToken,
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
index acb6010ab27b4..6fc7ee83bfd14 100644
--- a/include/swift/SIL/SILBuilder.h
+++ b/include/swift/SIL/SILBuilder.h
@@ -549,6 +549,18 @@ class SILBuilder {
         NormalDifferentiableFunctionTypeComponent::Original, TheFunction));
   }
 
+  DifferentiabilityWitnessFunctionInst *
+  createDifferentiabilityWitnessFunction(
+      SILLocation Loc, SILFunction *OriginalFunction,
+      DifferentiabilityWitnessFunctionKind WitnessKind,
+      IndexSubset *ParameterIndices, IndexSubset *ResultIndices,
+      GenericSignature *WitnessGenericSignature) {
+    return insert(new (getModule()) DifferentiabilityWitnessFunctionInst(
+        getModule(), getSILDebugLocation(Loc), OriginalFunction, WitnessKind,
+        ParameterIndices, ResultIndices, WitnessGenericSignature));
+  }
+  // SWIFT_ENABLE_TENSORFLOW END
+
   BuiltinInst *createBuiltin(SILLocation Loc, Identifier Name, SILType ResultTy,
                              SubstitutionMap Subs,
                              ArrayRef<SILValue> Args) {
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
index 5fd3160d14078..b4f40c3bcf5b2 100644
--- a/include/swift/SIL/SILCloner.h
+++ b/include/swift/SIL/SILCloner.h
@@ -1011,6 +1011,17 @@ visitLinearFunctionExtractInst(LinearFunctionExtractInst *Inst) {
                 getOpLocation(Inst->getLoc()), Inst->getExtractee(),
                 getOpValue(Inst->getFunctionOperand())));
 }
+
+template<typename ImplClass>
+void SILCloner<ImplClass>::visitDifferentiabilityWitnessFunctionInst(
+    DifferentiabilityWitnessFunctionInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createDifferentiabilityWitnessFunction(
+                getOpLocation(Inst->getLoc()), Inst->getOriginalFunction(),
+                Inst->getWitnessKind(), Inst->getParameterIndices(),
+                Inst->getResultIndices(), Inst->getWitnessGenericSignature()));
+}
 // SWIFT_ENABLE_TENSORFLOW END
 
 template<typename ImplClass>
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
index 6a66cd8dd98b9..7abfcdf65457b 100644
--- a/include/swift/SIL/SILInstruction.h
+++ b/include/swift/SIL/SILInstruction.h
@@ -8031,6 +8031,54 @@ class LinearFunctionExtractInst
   ArrayRef<Operand> getAllOperands() const { return operands.asArray(); }
   MutableArrayRef<Operand> getAllOperands() { return operands.asArray(); }
 };
+
+class DifferentiabilityWitnessFunctionInst
+    : public InstructionBase<
+          SILInstructionKind::DifferentiabilityWitnessFunctionInst,
+          SingleValueInstruction> {
+private:
+  friend SILBuilder;
+  /// The original function.
+  SILFunction *originalFunction;
+  /// The differentiability witness function kind.
+  DifferentiabilityWitnessFunctionKind witnessKind;
+  /// The autodiff config: parameter indices, result indices, and witness
+  /// derivative signature.
+  AutoDiffConfig config;
+
+  static SILType getDifferentiabilityWitnessType(
+      SILModule &module, SILFunction *originalFunction,
+      DifferentiabilityWitnessFunctionKind witnessKind,
+      IndexSubset *parameterIndices, IndexSubset *resultIndices,
+      GenericSignature *witnessGenericSignature);
+
+public:
+  DifferentiabilityWitnessFunctionInst(
+      SILModule &module, SILDebugLocation loc, SILFunction *originalFunction,
+      DifferentiabilityWitnessFunctionKind witnessKind,
+      IndexSubset *parameterIndices, IndexSubset *resultIndices,
+      GenericSignature *witnessGenericSignature);
+
+  static DifferentiabilityWitnessFunctionInst *create(
+      SILModule &module, SILDebugLocation loc, SILFunction *originalFunction,
+      DifferentiabilityWitnessFunctionKind witnessKind,
+      IndexSubset *parameterIndices, IndexSubset *resultIndices,
+      GenericSignature *witnessGenericSignature);
+
+  DifferentiabilityWitnessFunctionKind getWitnessKind() const {
+    return witnessKind;
+  }
+  SILFunction *getOriginalFunction() const { return originalFunction; }
+  AutoDiffConfig const &getConfig() const { return config; }
+  IndexSubset *getParameterIndices() const { return config.parameterIndices; }
+  IndexSubset *getResultIndices() const { return config.resultIndices; }
+  GenericSignature *getWitnessGenericSignature() const {
+    return config.derivativeGenericSignature;
+  }
+
+  ArrayRef<Operand> getAllOperands() const { return {}; }
+  MutableArrayRef<Operand> getAllOperands() { return {}; }
+};
 // SWIFT_ENABLE_TENSORFLOW END
 
 // This is defined out of line to work around the fact that this depends on
diff --git a/include/swift/SIL/SILNodes.def b/include/swift/SIL/SILNodes.def
index 2caf4b5fe6e86..b8b28a90618be 100644
--- a/include/swift/SIL/SILNodes.def
+++ b/include/swift/SIL/SILNodes.def
@@ -700,6 +700,10 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   SINGLE_VALUE_INST(LinearFunctionExtractInst,
                     linear_function_extract,
                     SingleValueInstruction, None, DoesNotRelease)
+  SINGLE_VALUE_INST(DifferentiabilityWitnessFunctionInst,
+                    differentiability_witness_function,
+                    SingleValueInstruction, None, DoesNotRelease)
+  // SWIFT_ENABLE_TENSORFLOW END
 
   // Key paths
   // TODO: The only "side effect" is potentially retaining the returned key path
diff --git a/lib/AST/AutoDiff.cpp b/lib/AST/AutoDiff.cpp
index 2c01dd59d3791..ba22d9ce427c8 100644
--- a/lib/AST/AutoDiff.cpp
+++ b/lib/AST/AutoDiff.cpp
@@ -32,6 +32,25 @@ AutoDiffDerivativeFunctionKind(StringRef string) {
   rawValue = *result;
 }
 
+DifferentiabilityWitnessFunctionKind::
+DifferentiabilityWitnessFunctionKind(StringRef string) {
+  Optional<innerty> result = llvm::StringSwitch<Optional<innerty>>(string)
+      .Case("jvp", JVP)
+      .Case("vjp", VJP)
+      .Case("transpose", Transpose);
+  assert(result && "Invalid string");
+  rawValue = *result;
+}
+
+Optional<AutoDiffDerivativeFunctionKind>
+DifferentiabilityWitnessFunctionKind::getAsDerivativeFunctionKind() const {
+  switch (rawValue) {
+  case JVP: return {AutoDiffDerivativeFunctionKind::JVP};
+  case VJP: return {AutoDiffDerivativeFunctionKind::VJP};
+  case Transpose: return None;
+  }
+}
+
 NormalDifferentiableFunctionTypeComponent::
 NormalDifferentiableFunctionTypeComponent(AutoDiffDerivativeFunctionKind kind) {
   switch (kind) {
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
index fa92032fedf38..3db2756cbec4d 100644
--- a/lib/IRGen/IRGenSIL.cpp
+++ b/lib/IRGen/IRGenSIL.cpp
@@ -925,6 +925,8 @@ class IRGenSILFunction :
   void visitDifferentiableFunctionExtractInst(
       DifferentiableFunctionExtractInst *i);
   void visitLinearFunctionExtractInst(LinearFunctionExtractInst *i);
+  void visitDifferentiabilityWitnessFunctionInst(
+      DifferentiabilityWitnessFunctionInst *i);
   // SWIFT_ENABLE_TENSORFLOW END
 
   void visitFunctionRefBaseInst(FunctionRefBaseInst *i);
@@ -1927,6 +1929,13 @@ visitLinearFunctionExtractInst(LinearFunctionExtractInst *i) {
   setLoweredExplosion(i, e);
 }
 
+void IRGenSILFunction::visitDifferentiabilityWitnessFunctionInst(
+DifferentiabilityWitnessFunctionInst *i) {
+  // TODO(TF-916): Implement IRGen for `differentiability_witness_function`.
+  llvm_unreachable("unimplemented");
+}
+// SWIFT_ENABLE_TENSORFLOW END
+
 void IRGenSILFunction::visitFunctionRefBaseInst(FunctionRefBaseInst *i) {
   auto fn = i->getInitiallyReferencedFunction();
 
diff --git a/lib/ParseSIL/ParseSIL.cpp b/lib/ParseSIL/ParseSIL.cpp
index 6785ec708c95f..79bdac8cd920f 100644
--- a/lib/ParseSIL/ParseSIL.cpp
+++ b/lib/ParseSIL/ParseSIL.cpp
@@ -3091,6 +3091,110 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
         InstLoc, extractee, functionOperand);
     break;
   }
+  case SILInstructionKind::DifferentiabilityWitnessFunctionInst: {
+    // e.g. differentiability_witness_function
+    //      [jvp] [parameters 0 1] [results 0] <T where T: Differentiable>
+    //      @foo : $(T) -> T
+    DifferentiabilityWitnessFunctionKind witnessKind;
+    StringRef witnessKindNames[3] = {"jvp", "vjp", "transpose"};
+    SourceLoc lastLoc;
+    if (P.parseToken(tok::l_square,
+            diag::sil_inst_autodiff_expected_differentiability_witness_kind) ||
+        parseSILIdentifierSwitch(witnessKind, witnessKindNames,
+            diag::sil_inst_autodiff_expected_differentiability_witness_kind) ||
+        P.parseToken(tok::r_square, diag::sil_autodiff_expected_rsquare,
+                     "differentiability witness function kind"))
+      return true;
+    // Parse an index set, prefaced with the given label.
+    auto parseIndexSet = [&](StringRef label, SmallVectorImpl<unsigned> &indices,
+                             const Diagnostic &parseIndexDiag) -> bool {
+      // Parse `[<label> <integer_literal>...]`.
+      if (P.parseToken(tok::l_square, diag::sil_autodiff_expected_lsquare,
+                       "index list") ||
+          P.parseSpecificIdentifier(
+              label, diag::sil_autodiff_expected_index_list_label, label))
+        return true;
+      while (P.Tok.is(tok::integer_literal)) {
+        unsigned index;
+        if (P.parseUnsignedInteger(index, lastLoc, parseIndexDiag))
+          return true;
+        indices.push_back(index);
+      }
+      if (P.parseToken(tok::r_square, diag::sil_autodiff_expected_rsquare,
+                       "index list"))
+        return true;
+      return false;
+    };
+    // Parse parameter and result indices.
+    SmallVector<unsigned, 8> parameterIndices;
+    SmallVector<unsigned, 8> resultIndices;
+    if (parseIndexSet("parameters", parameterIndices,
+                      diag::sil_autodiff_expected_parameter_index))
+      return true;
+    if (parseIndexSet("results", resultIndices,
+                      diag::sil_autodiff_expected_result_index))
+      return true;
+    // Parse witness generic parameter clause.
+    GenericSignature *witnessGenSig = nullptr;
+    SourceLoc witnessGenSigStartLoc = P.getEndOfPreviousLoc();
+    {
+      // Create a new scope to avoid type redefinition errors.
+      Scope genericsScope(&P, ScopeKind::Generics);
+      auto *genericParams = P.parseSILGenericParams().getPtrOrNull();
+      if (genericParams) {
+        auto *witnessGenEnv =
+            handleSILGenericParams(P.Context, genericParams, &P.SF);
+        witnessGenSig = witnessGenEnv->getGenericSignature();
+      }
+    }
+    // Parse original function name and type.
+    SILFunction *originalFunction;
+    if (parseSILFunctionRef(InstLoc, originalFunction))
+      return true;
+    // Resolve parsed witness generic signature.
+    if (witnessGenSig) {
+      auto origGenSig = originalFunction
+          ->getLoweredFunctionType()->getGenericSignature();
+      // Check whether original function generic signature and parsed witness
+      // generic have the same generic parameters.
+      auto areGenericParametersConsistent = [&]() {
+        llvm::DenseSet<GenericParamKey> genericParamKeys;
+        for (auto *origGP : origGenSig->getGenericParams())
+          genericParamKeys.insert(GenericParamKey(origGP));
+        for (auto *witnessGP : witnessGenSig->getGenericParams())
+          if (!genericParamKeys.erase(GenericParamKey(witnessGP)))
+            return false;
+        return genericParamKeys.empty();
+      };
+      if (!areGenericParametersConsistent()) {
+        P.diagnose(witnessGenSigStartLoc,
+                   diag::sil_inst_autodiff_invalid_witness_generic_signature,
+                   witnessGenSig->getAsString(), origGenSig->getAsString());
+        return true;
+      }
+      // Combine parsed witness requirements with original function generic
+      // signature requirements to form full witness generic signature.
+      SmallVector<Requirement, 4> witnessRequirements(
+          witnessGenSig->getRequirements().begin(),
+          witnessGenSig->getRequirements().end());
+      witnessGenSig = evaluateOrDefault(
+          P.Context.evaluator,
+          AbstractGenericSignatureRequest{
+              origGenSig,
+              /*addedGenericParams=*/{},
+              std::move(witnessRequirements)},
+              nullptr);
+    }
+    auto origFnType = originalFunction->getLoweredFunctionType();
+    auto *parameterIndexSet = IndexSubset::get(
+        P.Context, origFnType->getNumParameters(), parameterIndices);
+    auto *resultIndexSet = IndexSubset::get(
+        P.Context, origFnType->getNumResults(), resultIndices);
+    ResultVal = B.createDifferentiabilityWitnessFunction(
+        InstLoc, originalFunction, witnessKind, parameterIndexSet,
+        resultIndexSet, witnessGenSig);
+    break;
+  }
   // SWIFT_ENABLE_TENSORFLOW END
 
   case SILInstructionKind::DynamicFunctionRefInst: {
diff --git a/lib/SIL/OperandOwnership.cpp b/lib/SIL/OperandOwnership.cpp
index 9c9ed6013b158..0634462c4aac6 100644
--- a/lib/SIL/OperandOwnership.cpp
+++ b/lib/SIL/OperandOwnership.cpp
@@ -136,6 +136,9 @@ SHOULD_NEVER_VISIT_INST(Unwind)
 SHOULD_NEVER_VISIT_INST(ReleaseValue)
 SHOULD_NEVER_VISIT_INST(ReleaseValueAddr)
 SHOULD_NEVER_VISIT_INST(StrongRelease)
+// SWIFT_ENABLE_TENSORFLOW
+SHOULD_NEVER_VISIT_INST(DifferentiabilityWitnessFunction)
+// SWIFT_ENABLE_TENSORFLOW END
 #define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
   SHOULD_NEVER_VISIT_INST(StrongRetain##Name)                                  \
   SHOULD_NEVER_VISIT_INST(Name##Retain)
diff --git a/lib/SIL/SILInstructions.cpp b/lib/SIL/SILInstructions.cpp
index 06a8b5ed48b51..8db118fd86f3b 100644
--- a/lib/SIL/SILInstructions.cpp
+++ b/lib/SIL/SILInstructions.cpp
@@ -714,6 +714,39 @@ LinearFunctionExtractInst::LinearFunctionExtractInst(
     : InstructionBase(debugLoc,
                       getExtracteeType(theFunction, extractee, module)),
       extractee(extractee), operands(this, theFunction) {}
+
+SILType DifferentiabilityWitnessFunctionInst::getDifferentiabilityWitnessType(
+    SILModule &module, SILFunction *originalFunction,
+    DifferentiabilityWitnessFunctionKind witnessKind,
+    IndexSubset *parameterIndices, IndexSubset *resultIndices,
+    GenericSignature *witnessGenSig) {
+  auto fnTy = originalFunction->getLoweredFunctionType();
+  CanGenericSignature witnessCanGenSig;
+  if (witnessGenSig)
+    witnessCanGenSig = witnessGenSig->getCanonicalSignature();
+  if (auto derivativeKind = witnessKind.getAsDerivativeFunctionKind()) {
+    auto diffFnTy = fnTy->getAutoDiffDerivativeFunctionType(
+       parameterIndices, *resultIndices->begin(), *derivativeKind, module.Types,
+       LookUpConformanceInModule(module.getSwiftModule()), witnessCanGenSig);
+    return SILType::getPrimitiveObjectType(diffFnTy);
+  }
+  assert(witnessKind == DifferentiabilityWitnessFunctionKind::Transpose);
+  auto transposeFnTy = fnTy->getAutoDiffTransposeFunctionType(
+      parameterIndices, module.Types,
+      LookUpConformanceInModule(module.getSwiftModule()), witnessCanGenSig);
+  return SILType::getPrimitiveObjectType(transposeFnTy);
+}
+
+DifferentiabilityWitnessFunctionInst::DifferentiabilityWitnessFunctionInst(
+    SILModule &module, SILDebugLocation debugLoc, SILFunction *originalFunction,
+    DifferentiabilityWitnessFunctionKind witnessKind,
+    IndexSubset *parameterIndices, IndexSubset *resultIndices,
+    GenericSignature *witnessGenSig)
+    : InstructionBase(debugLoc, getDifferentiabilityWitnessType(
+          module, originalFunction, witnessKind, parameterIndices,
+          resultIndices, witnessGenSig)),
+      originalFunction(originalFunction), witnessKind(witnessKind),
+      config({parameterIndices, resultIndices, witnessGenSig}) {}
 // SWIFT_ENABLE_TENSORFLOW END
 
 FunctionRefBaseInst::FunctionRefBaseInst(SILInstructionKind Kind,
diff --git a/lib/SIL/SILPrinter.cpp b/lib/SIL/SILPrinter.cpp
index 331fc3afd25be..4da333038d83b 100644
--- a/lib/SIL/SILPrinter.cpp
+++ b/lib/SIL/SILPrinter.cpp
@@ -447,6 +447,51 @@ void SILType::dump() const {
   llvm::errs() << '\n';
 }
 
+// TODO(TF-893): Use this helper to dedupe the same logic in
+// `SILFunction::print`.
+static void printSILFunctionNameAndType(
+    llvm::raw_ostream &OS, SILFunction *function) {
+  function->printName(OS);
+  OS << " : $";
+  llvm::DenseMap<CanType, Identifier> Aliases;
+  llvm::DenseSet<Identifier> UsedNames;
+  auto sig = function->getLoweredFunctionType()->getGenericSignature();
+  auto env = function->getGenericEnvironment();
+  if (sig && env) {
+    llvm::SmallString<16> disambiguatedNameBuf;
+    unsigned disambiguatedNameCounter = 1;
+    for (auto *paramTy : sig->getGenericParams()) {
+      auto sugaredTy = env->getSugaredType(paramTy);
+      Identifier name = sugaredTy->getName();
+      while (!UsedNames.insert(name).second) {
+        disambiguatedNameBuf.clear();
+        {
+          llvm::raw_svector_ostream names(disambiguatedNameBuf);
+          names << sugaredTy->getName() << disambiguatedNameCounter++;
+        }
+        name = function->getASTContext().getIdentifier(disambiguatedNameBuf);
+      }
+      if (name != sugaredTy->getName()) {
+        Aliases[paramTy->getCanonicalType()] = name;
+
+        // Also for the archetype
+        auto archetypeTy = env->mapTypeIntoContext(paramTy)
+            ->getAs<ArchetypeType>();
+        if (archetypeTy)
+          Aliases[archetypeTy->getCanonicalType()] = name;
+      }
+    }
+  }
+
+  {
+    PrintOptions withGenericEnvironment = PrintOptions::printSIL();
+    withGenericEnvironment.GenericEnv = env;
+    withGenericEnvironment.AlternativeTypeNames =
+      Aliases.empty() ? nullptr : &Aliases;
+    function->getLoweredFunctionType()->print(OS, withGenericEnvironment);
+  }
+}
+
 namespace {
   
 class SILPrinter;
@@ -1222,6 +1267,36 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << getIDAndType(lfei->getFunctionOperand());
   }
 
+  void visitDifferentiabilityWitnessFunctionInst(
+      DifferentiabilityWitnessFunctionInst *dwfi) {
+    *this << '[';
+    switch (dwfi->getWitnessKind()) {
+    case DifferentiabilityWitnessFunctionKind::JVP:
+      *this << "jvp";
+      break;
+    case DifferentiabilityWitnessFunctionKind::VJP:
+      *this << "vjp";
+      break;
+    case DifferentiabilityWitnessFunctionKind::Transpose:
+      *this << "transpose";
+      break;
+    }
+    *this << "] [parameters";
+    for (auto i : dwfi->getParameterIndices()->getIndices())
+      *this << ' ' << i;
+    *this << "] [results";
+    for (auto i : dwfi->getResultIndices()->getIndices())
+      *this << ' ' << i;
+    *this << "] ";
+    if (auto *witnessGenSig = dwfi->getWitnessGenericSignature()) {
+      auto subPrinter = PrintOptions::printSIL();
+      witnessGenSig->print(PrintState.OS, subPrinter);
+      *this << " ";
+    }
+    printSILFunctionNameAndType(PrintState.OS, dwfi->getOriginalFunction());
+  }
+  // SWIFT_ENABLE_TENSORFLOW END
+
   void visitFunctionRefInst(FunctionRefInst *FRI) {
     FRI->getInitiallyReferencedFunction()->printName(PrintState.OS);
     *this << " : " << FRI->getType();
@@ -3085,51 +3160,6 @@ void SILDefaultWitnessTable::dump() const {
   print(llvm::errs());
 }
 
-// TODO(TF-893): Use this helper to dedupe the same logic in
-// `SILFunction::print`.
-static void printSILFunctionNameAndType(
-    llvm::raw_ostream &OS, SILFunction *function) {
-  function->printName(OS);
-  OS << " : $";
-  llvm::DenseMap<CanType, Identifier> Aliases;
-  llvm::DenseSet<Identifier> UsedNames;
-  auto sig = function->getLoweredFunctionType()->getGenericSignature();
-  auto *env = function->getGenericEnvironment();
-  if (sig && env) {
-    llvm::SmallString<16> disambiguatedNameBuf;
-    unsigned disambiguatedNameCounter = 1;
-    for (auto *paramTy : sig->getGenericParams()) {
-      auto sugaredTy = env->getSugaredType(paramTy);
-      Identifier name = sugaredTy->getName();
-      while (!UsedNames.insert(name).second) {
-        disambiguatedNameBuf.clear();
-        {
-          llvm::raw_svector_ostream names(disambiguatedNameBuf);
-          names << sugaredTy->getName() << disambiguatedNameCounter++;
-        }
-        name = function->getASTContext().getIdentifier(disambiguatedNameBuf);
-      }
-      if (name != sugaredTy->getName()) {
-        Aliases[paramTy->getCanonicalType()] = name;
-
-        // Also for the archetype
-        auto archetypeTy = env->mapTypeIntoContext(paramTy)
-            ->getAs<ArchetypeType>();
-        if (archetypeTy)
-          Aliases[archetypeTy->getCanonicalType()] = name;
-      }
-    }
-  }
-
-  {
-    PrintOptions withGenericEnvironment = PrintOptions::printSIL();
-    withGenericEnvironment.GenericEnv = env;
-    withGenericEnvironment.AlternativeTypeNames =
-      Aliases.empty() ? nullptr : &Aliases;
-    function->getLoweredFunctionType()->print(OS, withGenericEnvironment);
-  }
-}
-
 // SWIFT_ENABLE_TENSORFLOW
 void SILDifferentiabilityWitness::print(
     llvm::raw_ostream &OS, bool verbose) const {
diff --git a/lib/SIL/ValueOwnership.cpp b/lib/SIL/ValueOwnership.cpp
index 7af1d9f02db72..40985f93b69a7 100644
--- a/lib/SIL/ValueOwnership.cpp
+++ b/lib/SIL/ValueOwnership.cpp
@@ -147,6 +147,9 @@ CONSTANT_OWNERSHIP_INST(Any, ValueMetatype)
 CONSTANT_OWNERSHIP_INST(Any, WitnessMethod)
 CONSTANT_OWNERSHIP_INST(Any, StoreBorrow)
 CONSTANT_OWNERSHIP_INST(Any, ConvertEscapeToNoEscape)
+// SWIFT_ENABLE_TENSORFLOW
+CONSTANT_OWNERSHIP_INST(Any, DifferentiabilityWitnessFunction)
+// SWIFT_ENABLE_TENSORFLOW END
 CONSTANT_OWNERSHIP_INST(Unowned, InitBlockStorageHeader)
 // TODO: It would be great to get rid of these.
 CONSTANT_OWNERSHIP_INST(Unowned, RawPointerToRef)
diff --git a/lib/SILOptimizer/Utils/SILInliner.cpp b/lib/SILOptimizer/Utils/SILInliner.cpp
index 1c767de852fa4..c29b56d5e7c8d 100644
--- a/lib/SILOptimizer/Utils/SILInliner.cpp
+++ b/lib/SILOptimizer/Utils/SILInliner.cpp
@@ -758,6 +758,7 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
   case SILInstructionKind::LinearFunctionInst:
   case SILInstructionKind::DifferentiableFunctionExtractInst:
   case SILInstructionKind::LinearFunctionExtractInst:
+  case SILInstructionKind::DifferentiabilityWitnessFunctionInst:
   // SWIFT_ENABLE_TENSORFLOW END
   case SILInstructionKind::AllocBoxInst:
   case SILInstructionKind::AllocExistentialBoxInst:
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
index 625e91ee11093..c152508bf7083 100644
--- a/lib/Serialization/DeserializeSIL.cpp
+++ b/lib/Serialization/DeserializeSIL.cpp
@@ -1029,7 +1029,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
   Builder.setCurrentDebugScope(Fn->getDebugScope());
   unsigned RawOpCode = 0, TyCategory = 0, TyCategory2 = 0, TyCategory3 = 0,
            // SWIFT_ENABLE_TENSORFLOW
-           Attr = 0, Attr2 = 0, NumSubs = 0, NumConformances = 0,
+           Attr = 0, Attr2 = 0, Attr3 = 0, NumSubs = 0, NumConformances = 0,
            IsNonThrowingApply = 0;
   ValueID ValID, ValID2, ValID3;
   TypeID TyID, TyID2, TyID3;
@@ -1154,6 +1154,15 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
         scratch, TyID, TyCategory, ValID, /*extractee*/ Attr);
     RawOpCode = (unsigned)SILInstructionKind::LinearFunctionExtractInst;
     break;
+  case SIL_INST_DIFFERENTIABILITY_WITNESS_FUNCTION:
+    SILInstDifferentiabilityWitnessFunctionLayout::readRecord(
+        scratch, /*originalFunctionName*/ ValID, /*witnessKind*/ Attr,
+        /*witnessGenSig*/ ValID2, /*numParams*/ Attr2, /*numResults*/ Attr3,
+        ListOfValues);
+    RawOpCode =
+        (unsigned)SILInstructionKind::DifferentiabilityWitnessFunctionInst;
+    break;
+  // SWIFT_ENABLE_TENSORFLOW END
   case SIL_INST_NO_OPERAND:
     SILInstNoOperandLayout::readRecord(scratch, RawOpCode);
     break;
@@ -1612,6 +1621,32 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
     ResultVal = Builder.createLinearFunctionExtract(Loc, extractee, val);
     break;
   }
+  case SILInstructionKind::DifferentiabilityWitnessFunctionInst: {
+    auto originalName = MF->getIdentifierText(ValID);
+    auto *original = getFuncForReference(originalName);
+    assert(original && "Original function must be found");
+    DifferentiabilityWitnessFunctionKind witnessKind(Attr);
+    auto numParameterIndices = Attr2;
+    auto numResultIndices = Attr3;
+    SmallVector<unsigned, 8> parameterAndResultIndices(ListOfValues.begin(),
+                                                       ListOfValues.end());
+    assert(parameterAndResultIndices.size() ==
+               numParameterIndices + numResultIndices &&
+           "Parameter/result indices count mismatch");
+    auto *parameterIndices = IndexSubset::get(
+        MF->getContext(), original->getLoweredFunctionType()->getNumParameters(),
+        ArrayRef<unsigned>(parameterAndResultIndices)
+            .take_front(numParameterIndices));
+    auto *resultIndices = IndexSubset::get(
+        MF->getContext(), original->getLoweredFunctionType()->getNumResults(),
+        ArrayRef<unsigned>(parameterAndResultIndices)
+            .take_back(numResultIndices));
+    auto *witnessGenSig = MF->getGenericSignature(ValID2);
+    ResultVal = Builder.createDifferentiabilityWitnessFunction(
+        Loc, original, witnessKind, parameterIndices, resultIndices,
+        witnessGenSig);
+    break;
+  }
   // SWIFT_ENABLE_TENSORFLOW END
   case SILInstructionKind::AllocGlobalInst: {
     // Format: Name and type. Use SILOneOperandLayout.
diff --git a/lib/Serialization/SILFormat.h b/lib/Serialization/SILFormat.h
index 55aa573473d4c..66fa50d0523e9 100644
--- a/lib/Serialization/SILFormat.h
+++ b/lib/Serialization/SILFormat.h
@@ -182,6 +182,7 @@ namespace sil_block {
     SIL_INST_LINEAR_FUNCTION,
     SIL_INST_DIFFERENTIABLE_FUNCTION_EXTRACT,
     SIL_INST_LINEAR_FUNCTION_EXTRACT,
+    SIL_INST_DIFFERENTIABILITY_WITNESS_FUNCTION,
     SIL_DIFFERENTIABILITY_WITNESS,
     // SWIFT_ENABLE_TENSORFLOW END
 
@@ -464,6 +465,16 @@ namespace sil_block {
     ValueIDField,
     BCFixed<1> // extractee
   >;
+
+  using SILInstDifferentiabilityWitnessFunctionLayout = BCRecordLayout<
+    SIL_INST_DIFFERENTIABILITY_WITNESS_FUNCTION,
+    DeclIDField,             // Original function name
+    BCFixed<2>,              // Witness kind (JVP or VJP or transpose)
+    GenericSignatureIDField, // Witness generic signature
+    BCVBR<8>,                // Number of parameter indices
+    BCVBR<8>,                // Number of result indices
+    BCArray<ValueIDField>    // Parameter and result indices
+  >;
   // SWIFT_ENABLE_TENSORFLOW END
 
   // SIL instructions with one type. (alloc_stack)
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
index 4697c25c39c4b..49e36ef22e959 100644
--- a/lib/Serialization/Serialization.cpp
+++ b/lib/Serialization/Serialization.cpp
@@ -790,6 +790,7 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(sil_block, SIL_INST_DIFFERENTIABLE_FUNCTION_EXTRACT);
   BLOCK_RECORD(sil_block, SIL_INST_LINEAR_FUNCTION_EXTRACT);
   BLOCK_RECORD(sil_block, SIL_DIFFERENTIABILITY_WITNESS);
+  BLOCK_RECORD(sil_block, SIL_INST_DIFFERENTIABILITY_WITNESS_FUNCTION);
   // SWIFT_ENABLE_TENSORFLOW END
 
   // These layouts can exist in both decl blocks and sil blocks.
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
index e029ec3e0cc17..6e7328fc5826e 100644
--- a/lib/Serialization/SerializeSIL.cpp
+++ b/lib/Serialization/SerializeSIL.cpp
@@ -1058,6 +1058,26 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
         rawExtractee);
     break;
   }
+  case SILInstructionKind::DifferentiabilityWitnessFunctionInst: {
+    auto *dwfi = cast<DifferentiabilityWitnessFunctionInst>(&SI);
+    auto originalFnName = addSILFunctionRef(dwfi->getOriginalFunction());
+    auto rawWitnessKind = (unsigned)dwfi->getWitnessKind();
+    SmallVector<unsigned, 8> parameterAndResultIndices(
+        dwfi->getParameterIndices()->begin(),
+        dwfi->getParameterIndices()->end());
+    parameterAndResultIndices.append(dwfi->getResultIndices()->begin(),
+                                     dwfi->getResultIndices()->end());
+    SILInstDifferentiabilityWitnessFunctionLayout::emitRecord(
+        Out, ScratchRecord,
+        SILAbbrCodes[SILInstDifferentiabilityWitnessFunctionLayout::Code],
+        originalFnName, rawWitnessKind,
+        S.addGenericSignatureRef(dwfi->getWitnessGenericSignature()),
+        dwfi->getParameterIndices()->getNumIndices(),
+        dwfi->getResultIndices()->getNumIndices(),
+        parameterAndResultIndices);
+    break;
+  }
+  // SWIFT_ENABLE_TENSORFLOW END
   case SILInstructionKind::ApplyInst: {
     // Format: attributes such as transparent and number of substitutions,
     // the callee's substituted and unsubstituted types, a value for
@@ -2648,6 +2668,7 @@ void SILSerializer::writeSILBlock(const SILModule *SILMod) {
   registerSILAbbr<SILInstLinearFunctionLayout>();
   registerSILAbbr<SILInstDifferentiableFunctionExtractLayout>();
   registerSILAbbr<SILInstLinearFunctionExtractLayout>();
+  registerSILAbbr<SILInstDifferentiabilityWitnessFunctionLayout>();
   // SWIFT_ENABLE_TENSORFLOW END
 
   // Register the abbreviation codes so these layouts can exist in both
diff --git a/test/AutoDiff/differentiability_witness_function_inst.sil b/test/AutoDiff/differentiability_witness_function_inst.sil
new file mode 100644
index 0000000000000..425bd8c21df4f
--- /dev/null
+++ b/test/AutoDiff/differentiability_witness_function_inst.sil
@@ -0,0 +1,76 @@
+// RUN: %target-sil-opt %s | %FileCheck %s
+
+// RUN: %empty-directory(%t)
+// RUN: %target-sil-opt %s -emit-sib -o %t/tmp.sib -module-name main
+// RUN: %target-sil-opt %t/tmp.sib -o %t/tmp.2.sib -module-name main
+// RUN: %target-sil-opt %t/tmp.2.sib -module-name main | %FileCheck %s
+
+sil_stage raw
+
+import Swift
+import Builtin
+
+sil @foo : $@convention(thin) (Float, Float, Float) -> Float
+
+sil @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+
+sil @generic : $@convention(thin) <T> (@in_guaranteed T, Float) -> @out T
+
+sil @genericreq : $@convention(thin) <T : FloatingPoint> (@in_guaranteed T, Float) -> @out T
+
+sil @test_derivative_witnesses : $@convention(thin) () -> () {
+bb0:
+  %foo_jvp_wrt_0 = differentiability_witness_function [jvp] [parameters 0] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+  %foo_vjp_wrt_0_1 = differentiability_witness_function [vjp] [parameters 0 1] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+
+  // Test multiple results.
+  %bar_jvp_wrt_0_results_0 = differentiability_witness_function [jvp] [parameters 0] [results 0] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+  %bar_vjp_wrt_0_1_results_0_1 = differentiability_witness_function [vjp] [parameters 0 1] [results 0 1] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+
+  // Test generic requirements.
+  %generic_jvp_wrt_0 = differentiability_witness_function [jvp] [parameters 0] [results 0] <T : Differentiable> @generic : $@convention(thin) <T> (@in_guaranteed T, Float) -> @out T
+  %generic_vjp_wrt_0_1 = differentiability_witness_function [vjp] [parameters 0 1] [results 0] <T : Differentiable & AdditiveArithmetic> @generic : $@convention(thin) <T> (@in_guaranteed T, Float) -> @out T
+
+  // Test "dependent" generic requirements: `T == T.TangentVector` depends on `T: Differentiable`.
+  %generic_vjp_wrt_0_1_dependent_req = differentiability_witness_function [vjp] [parameters 0 1] [results 0] <T where T: Differentiable, T == T.TangentVector> @generic : $@convention(thin) <T> (@in_guaranteed T, Float) -> @out T
+  return undef : $()
+}
+
+sil @test_transpose_witnesses : $@convention(thin) () -> () {
+bb0:
+  %foo_t_wrt_0 = differentiability_witness_function [transpose] [parameters 0] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+  %foo_t_wrt_0_1 = differentiability_witness_function [transpose] [parameters 0 1] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+
+  // Test multiple results.
+  %bar_t_wrt_0_results_0 = differentiability_witness_function [transpose] [parameters 0] [results 0] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+  %bar_t_wrt_0_1_results_0_1 = differentiability_witness_function [transpose] [parameters 0 1] [results 0 1] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+
+  // Test generic requirements.
+  %generic_t_wrt_0 = differentiability_witness_function [transpose] [parameters 0] [results 0] <T : Differentiable> @generic : $@convention(thin) <T> (@in_guaranteed T, Float) -> @out T
+  %generic_t_wrt_0_1 = differentiability_witness_function [transpose] [parameters 0 1] [results 0] <T : AdditiveArithmetic & Differentiable> @generic : $@convention(thin) <T> (@in_guaranteed T, Float) -> @out T
+
+  // Test "dependent" generic requirements: `T == T.TangentVector` depends on `T: Differentiable`.
+  %generic_t_wrt_0_1_dependent_req = differentiability_witness_function [transpose] [parameters 0 1] [results 0] <T where T: Differentiable, T == T.TangentVector> @generic : $@convention(thin) <T> (@in_guaranteed T, Float) -> @out T
+  return undef : $()
+}
+
+// CHECK-LABEL: sil @test_derivative_witnesses : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK:   {{%.*}} = differentiability_witness_function [jvp] [parameters 0] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+// CHECK:   {{%.*}} = differentiability_witness_function [vjp] [parameters 0 1] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+// CHECK:   {{%.*}} = differentiability_witness_function [jvp] [parameters 0] [results 0] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+// CHECK:   {{%.*}} = differentiability_witness_function [vjp] [parameters 0 1] [results 0 1] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+// CHECK:   {{%.*}} = differentiability_witness_function [jvp] [parameters 0] [results 0] <τ_0_0 where τ_0_0 : _Differentiable> @generic : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Float) -> @out τ_0_0
+// CHECK:   {{%.*}} = differentiability_witness_function [vjp] [parameters 0 1] [results 0] <τ_0_0 where τ_0_0 : AdditiveArithmetic, τ_0_0 : _Differentiable> @generic : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Float) -> @out τ_0_0
+// CHECK: }
+
+// CHECK-LABEL: sil @test_transpose_witnesses : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK:   {{%.*}} = differentiability_witness_function [transpose] [parameters 0] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+// CHECK:   {{%.*}} = differentiability_witness_function [transpose] [parameters 0 1] [results 0] @foo : $@convention(thin) (Float, Float, Float) -> Float
+// CHECK:   {{%.*}} = differentiability_witness_function [transpose] [parameters 0] [results 0] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+// CHECK:   {{%.*}} = differentiability_witness_function [transpose] [parameters 0 1] [results 0 1] @bar : $@convention(thin) (Float, Float, Float) -> (Float, Float)
+// CHECK:   {{%.*}} = differentiability_witness_function [transpose] [parameters 0] [results 0] <τ_0_0 where τ_0_0 : _Differentiable> @generic : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Float) -> @out τ_0_0
+// CHECK:   {{%.*}} = differentiability_witness_function [transpose] [parameters 0 1] [results 0] <τ_0_0 where τ_0_0 : _Differentiable, τ_0_0 == τ_0_0.TangentVector> @generic : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Float) -> @out τ_0_0
+// CHECK:   return undef : $()
+// CHECK: }