Exception access violation with Enzyme ("Incorrect number of arguments passed to called function!")

[timholy]

includeing the following script:

using DifferentiationInterface
using Enzyme: Enzyme, Const, Forward, Reverse, Active, Duplicated, autodiff_deferred
using Test

function f(x)
    @assert axes(x) == (Base.OneTo(2),)
    (x1, x2) = x
    objvar = ((((((4 * x1*x1 - 2.1 * x1^4) + (((((0.333333333333333x1) * x1) * x1) * x1) * x1) * x1) + x1 * x2) - 4 * x2*x2) + 4 * x2^4))
    return objvar
end
x0 = [1.0, 1.0]

backend = AutoEnzyme()

prepg = prepare_gradient(f, backend, x0)
preph = prepare_hessian(f, backend, x0)
∇f(x) = gradient(f, prepg, backend, x)
∇²f(x) = hessian(f, preph, backend, x)

# For Enzyme, it works if you comment out the previous 4 lines and use these instead:

# ∇f(x) = only(Enzyme.gradient(Reverse, f, x))
# function gradient_deferred(f, x)
#     dx = zeros(length(x))
#     autodiff_deferred(Reverse, Const(f), Active, Duplicated(x, dx))
#     dx
# end
# ∇²f(x0) = only(Enzyme.jacobian(Forward, x -> gradient_deferred(f, x), x0))

@test isreal(f(x0))
g, H = ∇f(x0), ∇²f(x0)
@test isa(g, AbstractVector{<:Real})
@test isa(H, AbstractMatrix{<:Real})
@test length(g) == 2
@test size(H) == (2, 2)

causes

julia> include("dibug.jl")
Incorrect number of arguments passed to called function!
  %106 = call fast fastcc double @julia___154(double %arrayref12.i.i, double (double)* sub (double (double)* @julia___154,
Please submit a bug report with steps to reproduce this fault, and any error messages that follow (in their entirety). Thanks.
Exception: EXCEPTION_ACCESS_VIOLATION at 0x6de7b473 -- .text$_ZN12_GLOBAL__N_112TypePrinting5printEPN4llvm4TypeERNS1_11raw_ostreamE at C:\Users\timho\.julia\juliaup\julia-1.10.10+0.x64.w64.mingw32\bin\libLLVM-15jl.dll (unknown line)
in expression starting at C:\Users\timho\OneDrive\Documents\publications\biquadraticoptim\src\testproblems\gams\dibug.jl:31
 ⋮

The issue is not the @assert, instead it's the x^4. (This example looks strange because it's a lightly-edited repro of the "camel1.gms" file parsed by GAMSFiles.) The script passes correctly if you instead use

using ForwardDiff: ForwardDiff

backend = AutoForwardDiff()

suggesting that it's not some problem with how the script is written.

Note that I've included in a commented block an implementation in terms of the Enzyme API that succeeds. The key is the use of autodiff_deferred and Duplicated in the reverse-mode evaluation of the gradient. I tried DI with backend = AutoEnzyme(; function_annotation=Enzyme.Duplicated) but that is not sufficient to fix it (though it's a different error).

[gdalle]

At the moment there is no way to call autodiff_deferred from within DI, because I thought that in most cases it would no longer be necessary.
It seems like the present issue is a duplicate of EnzymeAD/Enzyme.jl#2445?

[gdalle]

Here's a simple pure-Enzyme reproducer, which shows that the behavior also depends on the value of the integer power:

using Enzyme

f3(x) = x[1]^3
f4(x) = x[1]^4

g3(x) = only(gradient(Reverse, f3, x))
g4(x) = only(gradient(Reverse, f4, x))

function g4_deferred(x)
    dx = zero(x)
    autodiff_deferred(Reverse, Const(f4), Active, Duplicated(x, dx))
    return dx
end

H3(x) = jacobian(Forward, g3, x)
H4(x) = jacobian(Forward, g4, x)
H4_deferred(x) = jacobian(Forward, g4_deferred, x)

Error only for H4:

julia> x0 = ones(2)
2-element Vector{Float64}:
 1.0
 1.0

julia> H3(x0)
([6.0 0.0; 0.0 0.0],)

julia> H4_deferred(x0)
([12.0 0.0; 0.0 0.0],)

julia> H4(x0)
Incorrect number of arguments passed to called function!
  %159 = call fast fastcc double @julia___24820(double %145, double (double)* @julia___24820), !dbg !365
; Function Attrs: mustprogress willreturn

julia> versioninfo()
Julia Version 1.11.5
Commit 760b2e5b739 (2025-04-14 06:53 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: macOS (arm64-apple-darwin24.0.0)
  CPU: 11 × Apple M3 Pro
  WORD_SIZE: 64
  LLVM: libLLVM-16.0.6 (ORCJIT, apple-m2)
Threads: 5 default, 0 interactive, 2 GC (on 5 virtual cores)
Environment:
  JULIA_EDITOR = code
  JULIA_VSCODE_REPL = 1

(_Scratchpad) pkg> st
Status `~/Documents/GitHub/Julia/_Scratchpad/Project.toml`
  [7da242da] Enzyme v0.13.56

[timholy]

Yes, sorry I didn't link that. I wondered if DI wanted to work around it, but of course that requires calling autodiff_deferred.

[gdalle]

To me, the fact that it doesn't error for power 3 but it errors for power 4 makes it look like a bug in Enzyme, so I'd wait until EnzymeAD/Enzyme.jl#2445 is fixed to see if there is still something here to do.
Back when autodiff_deferred was still necessary for higher-order, I had a mechanism in DI for detecting nested autodiff calls, and replacing autodiff with autodiff_deferred (see #285). But this was rather hacky and it didn't generalize to nesting outside of DI, which is why I'm happy we removed it when Enzyme v0.13 came along (see #471). I'd much rather rely on Enzyme to do as much as possible with autodiff if possible.

[wsmoses]

I believe this should be fixed.

FYI the reason for the differncee power is that julia itself emits different IR for different literal powers (sometimes using pow sometimes using multiplication).

[wsmoses]

That said it would still be quite useful to have an autodiff deferred wrapper -- e.g. for within gpu code

[gdalle]

Maybe as a type parameter in AutoEnzyme(; deferred=true/false)?