Add all differentiable_function instructions from the current SIL module to a worklist. While the differentiable_function worklist is not empty, pop the next one. If differentiable_function has JVP and VJP values, do nothing. It is already canonical. If differentiable_function is missing JVP and VJP: If the differentiable_function’s original function operand is an differentiable_function_extract [original] instruction, get the operand of that instruction. Do differentiable_function_extract [jvp/vjp] instruction from that operand to get the JVP/VJP. Continue. Otherwise, get the “original function reference” (function_ref, witness_method, or class_method instruction) underlying the differentiable_function’s original function operand. Look up a @differentiable declaration attribute on the “original function reference” whose parameter indices are a minimal superset of the differentiable_function’s parameter indices. If no such attribute exists, create an empty attribute with the differentiable_function’s parameter indices. Process the minimal superset SIL differentiability witness: If the attribute is missing the JVP function, generate a JVP function. If the attribute is missing the VJP function, generate a VJP function. Produce a reference to the JVP/VJP to fill in the differentiable_function instruction. JVP/VJP function generation is explained above. The pseudocode above does not mention how non-differentiability errors are handled. If a non-differentiable operation is encountered while processing a SIL differentiability witness or a differentiable_function instruction, the transform stops processing the item, continues onto the next item, and finally stops compilation after all items are processed. Special cases Reabstraction thunk differentiation Reabstraction thunks currently require special differentiation support. One common use case for reabstraction thunk differentiation is differentiating direct references to generic functions. Consider the following program: @_silgen_name("generic")func generic(_ x: T) -> T { return x}let _: @differentiable (Float) -> Float = generic This generates the following code in SIL (swiftc -emit-silgen): sil_stage raw import Builtin import Swift import SwiftShims func generic(_ x: T) -> T // main sil [ossa] @main : $@convention(c) (Int32, UnsafeMutablePointer>>) -> Int32 { bb0(%0 : $Int32, %1 : $UnsafeMutablePointer>>): // function_ref generic(_:) %2 = function_ref @$s4main7genericyxxlF : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0 // user: %3 %3 = partial_apply [callee_guaranteed] %2() : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0 // user: %5 // function_ref thunk for @escaping @callee_guaranteed (@in_guaranteed Float) -> (@out Float) %4 = function_ref @$sS2fIegnr_S2fIegyd_TR : $@convention(thin) (Float, @guaranteed @callee_guaranteed (@in_guaranteed Float) -> @out Float) -> Float // user: %5 %5 = partial_apply [callee_guaranteed] %4(%3) : $@convention(thin) (Float, @guaranteed @callee_guaranteed (@in_guaranteed Float) -> @out Float) -> Float // user: %6 %6 = differentiable_function [parameters 0] %5 : $@callee_guaranteed (Float) -> Float // user: %7 destroy_value %6 : $@differentiable @callee_guaranteed (Float) -> Float // id: %7 %8 = integer_literal $Builtin.Int32, 0 // user: %9 %9 = struct $Int32 (%8 : $Builtin.Int32) // user: %10 return %9 : $Int32 // id: %10 } // end sil function 'main' // generic (_:) sil hidden [ossa] @$s4main7genericyxxlF : $@convention(thin) (@in_guaranteed T) -> @out T { // %0 // user: %3 // %1 // users: %3, %2 bb0(%0 : $*T, %1 : $*T): debug_value_addr %1 : $*T, let, name "x", argno 1 // id: %2 copy_addr %1 to [initialization] %0 : $*T // id: %3 %4 = tuple () // user: %5