Forward-over-reverse: CallingConventionMismatchError parsing `idx_jl_getfield_aug` (type-unstable getfield of a Duplicated ODEProblem) — typeunstablerules.jl:1261

[ChrisRackauckas-Claude]

Summary

Forward-over-reverse (nested Enzyme: outer Forward over inner Reverse) through an ODE solve — using direct differentiation through the solver (sensealg = SensitivityADPassThrough(), i.e. no continuous-adjoint) — fails with an internal Enzyme error while parsing the calling convention of its own type-unstable getfield rule:

CallingConventionMismatchError: Enzyme hit an internal error trying to parse the julia calling
convention definition for:
  idx_jl_getfield_aug(::Val{@NamedTuple{1}}, ::SciMLBase.ODEProblem{Vector{Float64}, ...}, ...)
    @ Enzyme.Compiler ~/.julia/packages/Enzyme/.../src/rules/typeunstablerules.jl:1261

expectLen != length(parameters(f))
{} addrspace(10)* ({} addrspace(10)*, {} addrspace(10)**, i32, {} addrspace(10)**)
expectLen=1

The inner reverse succeeds (gradient is correct); only the outer forward over it fails, when it differentiates a getfield of the Duplicated ODEProblem through the type-unstable / generic-runtime getfield rule idx_jl_getfield_aug, whose generated function signature Enzyme then can't match (expectLen=1 vs the 4-parameter LLVM signature).

MWE (SciMLSensitivity + OrdinaryDiffEq + DiffEqBase + Enzyme; manual nesting)

import SciMLSensitivity as SMS   # loads the DiffEqBase Enzyme extension + SensitivityADPassThrough
import OrdinaryDiffEq as ODE
import DiffEqBase
import Enzyme

f(u, p, t) = -p[1] .* u
u0    = [1.0]
tspan = (0.0, 1.0)
ts    = range(0.0, 1.0, length = 5)

function loss(p)
    prob = ODE.ODEProblem(f, u0, tspan, p)
    sol  = ODE.solve(prob, ODE.Tsit5(); saveat = ts,
                     sensealg = DiffEqBase.SensitivityADPassThrough())  # differentiate THROUGH the solver
    sum(abs2, Array(sol))
end

const RA_R = Enzyme.set_runtime_activity(Enzyme.Reverse)
const RA_F = Enzyme.set_runtime_activity(Enzyme.Forward)

@noinline function grad(p)                 # inner reverse — works
    dp = zero(p)
    Enzyme.autodiff(RA_R, Enzyme.Const(loss), Enzyme.Active, Enzyme.Duplicated(p, dp))
    dp
end

grad([0.5])                                                    # [-2.4402421907949057]  (fine)
Enzyme.autodiff(RA_F, Enzyme.Const(p -> sum(grad(p))),        # outer forward over the reverse gradient
                Enzyme.Duplicated([0.5], [1.0]))
# CallingConventionMismatchError ... idx_jl_getfield_aug(::Val{@NamedTuple{1}}, ::ODEProblem, ...)
# @ typeunstablerules.jl:1261

Reduction attempts (why no dependency-free MWE)

I tried to reduce this to an Enzyme-only MWE without success (~6 shapes): forward-over-reverse of a getfield on an immutable/mutable struct with an active Vector field plus an ::Any field (ODEProblem-like); getfield returning the boxed Any field; and forcing the dynamic getfield path via Base.inferencebarrier, an ::Any-returning getter closure, and invokelatest. All return the correct derivative — the type-stable and even the dynamically-dispatched getfields I could construct don't land on the idx_jl_getfield_aug type-unstable-getfield rule the way the real solve_up reverse rule (getfielding a Duplicated ODEProblem inside runtime_generic_*) does. Filing with the SciML-stack MWE per maintainer preference; happy to keep reducing if a dependency-free repro is required.

Versions

• Enzyme v0.13.173
• SciMLSensitivity v7.112.2, OrdinaryDiffEq v7.1.1 / OrdinaryDiffEqCore v4.5.0, DiffEqBase v7.6.0, SciMLBase v3.30.1
• Julia 1.11.9

Context

Part of getting SecondOrder(AutoEnzyme(Forward), AutoEnzyme(Reverse)) forward-over-reverse Hessians/HVPs working through SciMLSensitivity + OrdinaryDiffEq (SciML/SciMLSensitivity.jl#1427). There are two routes to that second derivative, and each currently hits a distinct Enzyme forward-over-reverse blocker:

• continuous-adjoint route → Forward-over-reverse: Not yet implemented, mixed activity for jl_new_struct in runtime_generic_fwd when outer forward differentiates a dynamically-dispatched inner reverse rule (ODE adjoint) #3277 (mixed activity for jl_new_struct in runtime_generic_fwd);
• direct-through-solver route (this issue, SensitivityADPassThrough) → the idx_jl_getfield_aug calling-convention mismatch above.

(I used a Float64 problem to get past the separate Float32-only _ode_init type-analysis blocker #3276.) Prior cleared blockers in this chain: #3135 → #3137, #3213, #3246 → #3251, #3253 → #3254, #3258 → #3261.

[wsmoses]

@ChrisRackauckas-Claude keep reducing to an isolated mwe

[ChrisRackauckas-Claude]

Reduced to an Enzyme-only MWE. This keeps the same failure mode (idx_jl_getfield_aug under forward-over-reverse), but removes SciML/OrdinaryDiffEq entirely.

import Enzyme

const RA_R = Enzyme.set_runtime_activity(Enzyme.Reverse)
const RA_F = Enzyme.set_runtime_activity(Enzyme.Forward)

struct TwoFields
    a::Float64
    p::Vector{Float64}
end

@noinline function indexed_runtime_getfield(x, i)
    getfield(Base.inferencebarrier(x), Base.inferencebarrier(i))
end

@noinline function loss(p)
    q = indexed_runtime_getfield(TwoFields(1.0, p), 2)
    sum(abs2, q)
end

@noinline function grad(p)
    dp = zero(p)
    Enzyme.autodiff(RA_R, Enzyme.Const(loss), Enzyme.Active, Enzyme.Duplicated(p, dp))
    dp
end

@show grad([0.5])
@show Enzyme.autodiff(RA_F, Enzyme.Const(p -> sum(grad(p))), Enzyme.Duplicated([0.5], [1.0]))

I ran this locally on Julia 1.11.9 against current Enzyme.jl main (Enzyme v0.13.176 checkout). The inner reverse succeeds:

grad([0.5]) = [1.0]

Then the outer forward-over-reverse fails with:

CallingConventionMismatchError: Enzyme hit an internal error trying to parse the julia calling convention definition for:

idx_jl_getfield_aug(::Val{@NamedTuple{1}}, ::Base.RefValue{TwoFields}, ::Type{Val{1}}, ::Val{false})
     @ Enzyme.Compiler .../src/rules/typeunstablerules.jl:1272

expectLen != length(parameters(f))
{} addrspace(10)* ({} addrspace(10)*, {} addrspace(10)**, i32, {} addrspace(10)**)
expectLen=1

A one-field version does not reproduce for me:

struct HasVector
    p::Vector{Float64}
end

with getfield(..., 1) returns (2.0,) for the outer forward run. A two-field concrete struct with runtime-indexed getfield(..., 2) is enough.

[wsmoses]

@ChrisRackauckas-Claude this should be resolved on current release thoguh, right?

[ChrisRackauckas-Claude]

I rechecked against the current registered release in a fresh local env, and this reduced MWE still fails for me.

Setup/run:

JULIA_DEPOT_PATH=/home/crackauc/sandbox/tmp_20260706_131032_27625/.julia_depot_release \
  /home/crackauc/.juliaup/bin/julia +1.11 --project=repro_release -e 'import Pkg; Pkg.activate("repro_release"); Pkg.add("Enzyme"); Pkg.status()'

JULIA_DEPOT_PATH=/home/crackauc/sandbox/tmp_20260706_131032_27625/.julia_depot_release \
  /home/crackauc/.juliaup/bin/julia +1.11 --project=repro_release repro/issue3280_reduced.jl

The resolved package was:

Status `.../repro_release/Project.toml`
  [7da242da] Enzyme v0.13.176

The run prints the inner reverse result and then fails:

grad([0.5]) = [1.0]
ERROR: LoadError: CallingConventionMismatchError: Enzyme hit an internal error trying to parse the julia calling convention definition for:

idx_jl_getfield_aug(::Val{@NamedTuple{1}}, ::Base.RefValue{TwoFields}, ::Type{Val{1}}, ::Val{false})
     @ Enzyme.Compiler .../.julia_depot_release/packages/Enzyme/mAfXc/src/rules/typeunstablerules.jl:1272

expectLen != length(parameters(f))
{} addrspace(10)* ({} addrspace(10)*, {} addrspace(10)**, i32, {} addrspace(10)**)
expectLen=1

So unless there is a newer unregistered commit/release candidate you want me to test, I do not think this is resolved on the current registered release.

[ChrisRackauckas-Claude]

I also rechecked the original SciML/OrdinaryDiffEq MWE against a fresh latest registered stack, not just the Enzyme-only reduction.

Resolved versions:

DiffEqBase v7.6.0
Enzyme v0.13.176
OrdinaryDiffEq v7.1.1
SciMLSensitivity v7.113.0
Julia 1.11.9

Command:

JULIA_DEPOT_PATH=/home/crackauc/sandbox/tmp_20260706_131032_27625/.julia_depot_release \
  /home/crackauc/.juliaup/bin/julia +1.11 --project=repro_latest_sciml repro/issue3280_original.jl

Observed result: inner reverse still succeeds:

grad([0.5]) = [-2.4402421907949057]

Then the outer forward-over-reverse fails with the same class of error:

CallingConventionMismatchError: Enzyme hit an internal error trying to parse the julia calling convention definition for:

idx_jl_getfield_aug(::Val{@NamedTuple{1}}, ::SciMLBase.ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, false, Vector{Float64}, ...}, ::Type{Val{1}}, ::Val{false})
     @ Enzyme.Compiler .../.julia_depot_release/packages/Enzyme/mAfXc/src/rules/typeunstablerules.jl:1272

expectLen != length(parameters(f))
{} addrspace(10)* ({} addrspace(10)*, {} addrspace(10)**, i32, {} addrspace(10)**)
expectLen=1

So with current registered packages, both the reduced Enzyme-only MWE and the original SciML MWE still reproduce.