LLVM 18- generates non-existing `min.NaN.f64`/`max.NaN.f64` instructions

[giordano]

Sanity checks (read this first, then remove this section)

• Make sure you're reporting a bug; for general questions, please use Discourse or
  Slack.

• If you're dealing with a performance issue, make sure you disable scalar iteration
  (CUDA.allowscalar(false)). Only file an issue if that shows scalar iteration happening
  in CUDA.jl or Base Julia, as opposed to your own code.

• If you're seeing an error message, follow the error message instructions, if any
  (e.g. inspect code with @device_code_warntype). If you can't solve the problem using
  that information, make sure to post it as part of the issue.

• Always ensure you're using the latest version of CUDA.jl, and if possible, please
  check the master branch to see if your issue hasn't been resolved yet.

If your bug is still valid, please go ahead and fill out the template below.

Describe the bug

I'm trying to run https://github.com/WaterLily-jl/WaterLily-Benchmarks on GB200 with Julia v1.12 and I'm getting:

ERROR: LoadError: Failed to compile PTX code (ptxas exited with code 255)                                                                                                                                                  00:09:56 [6/1300]
Invocation arguments: --generate-line-info --verbose --gpu-name sm_100 --output-file /tmp/jl_MjiXQV2lej.cubin /tmp/jl_kD4L6b8dQb.ptx                                                                                                        
ptxas /tmp/jl_kD4L6b8dQb.ptx, line 119; error   : Illegal modifier '.NaN' for instruction 'max'                                                                                                                                             
ptxas /tmp/jl_kD4L6b8dQb.ptx, line 131; error   : Illegal modifier '.NaN' for instruction 'max'                                                                                                                                             
ptxas /tmp/jl_kD4L6b8dQb.ptx, line 147; error   : Illegal modifier '.NaN' for instruction 'max'                                                                                                                                             
ptxas /tmp/jl_kD4L6b8dQb.ptx, line 160; error   : Illegal modifier '.NaN' for instruction 'max'                                                                                                                                             
ptxas /tmp/jl_kD4L6b8dQb.ptx, line 181; error   : Illegal modifier '.NaN' for instruction 'max'                                                                                                                                             
ptxas /tmp/jl_kD4L6b8dQb.ptx, line 194; error   : Illegal modifier '.NaN' for instruction 'max'
ptxas fatal   : Ptx assembly aborted due to errors
If you think this is a bug, please file an issue and attach /tmp/jl_kD4L6b8dQb.ptx
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:44
  [2] compile(job::GPUCompiler.CompilerJob)
    @ CUDA ~/.julia/packages/CUDA/gqNji/src/compiler/compilation.jl:356
  [3] actual_compilation(cache::Dict{Any, CUDA.CuFunction}, src::Core.MethodInstance, world::UInt64, cfg::GPUCompiler.CompilerConfig{GPUCompiler.PTXCompilerTarget, CUDA.CUDACompilerParams}, compiler::typeof(CUDA.compile), linker::typeof
(CUDA.link))
    @ GPUCompiler ~/.julia/packages/GPUCompiler/Ecaql/src/execution.jl:245
  [4] cached_compilation(cache::Dict{Any, CUDA.CuFunction}, src::Core.MethodInstance, cfg::GPUCompiler.CompilerConfig{GPUCompiler.PTXCompilerTarget, CUDA.CUDACompilerParams}, compiler::Function, linker::Function)
    @ GPUCompiler ~/.julia/packages/GPUCompiler/Ecaql/src/execution.jl:159
  [5] macro expansion
    @ ~/.julia/packages/CUDA/gqNji/src/compiler/execution.jl:373 [inlined]
  [6] macro expansion
    @ ./lock.jl:376 [inlined]
  [7] cufunction(f::WaterLily.var"#gpu_##kern_#606#117", tt::Type{Tuple{KernelAbstractions.CompilerMetadata{KernelAbstractions.NDIteration.DynamicSize, KernelAbstractions.NDIteration.DynamicCheck, Nothing, CartesianIndices{3, Tuple{Base
.OneTo{Int64}, Base.OneTo{Int64}, Base.OneTo{Int64}}}, KernelAbstractions.NDIteration.NDRange{3, KernelAbstractions.NDIteration.DynamicSize, KernelAbstractions.NDIteration.StaticSize{(64, 1, 1)}, CartesianIndices{3, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}, Base.OneTo{Int64}}}, Nothing}}, CUDA.CuDeviceArray{Float32, 3, 1}, CUDA.CuDeviceArray{Float32, 4, 1}, CartesianIndex{3}}}; kwargs::@Kwargs{always_inline::Bool, maxthreads::Int64})
    @ CUDA ~/.julia/packages/CUDA/gqNji/src/compiler/execution.jl:368
  [8] macro expansion
    @ ~/.julia/packages/CUDA/gqNji/src/compiler/execution.jl:112 [inlined]
  [9] (::KernelAbstractions.Kernel{CUDA.CUDAKernels.CUDABackend, KernelAbstractions.NDIteration.StaticSize{(64,)}, KernelAbstractions.NDIteration.DynamicSize, WaterLily.var"#gpu_##kern_#606#117"})(::CuArray{Float32, 3, CUDA.DeviceMemory
}, ::Vararg{Any}; ndrange::Tuple{Int64, Int64, Int64}, workgroupsize::Nothing)
    @ CUDA.CUDAKernels ~/.julia/packages/CUDA/gqNji/src/CUDAKernels.jl:124
 [10] (::WaterLily.var"##kern#605#120"{Flow{3, Float32, CuArray{Float32, 3, CUDA.DeviceMemory}, CuArray{Float32, 4, CUDA.DeviceMemory}, CuArray{Float32, 5, CUDA.DeviceMemory}}})(σ::CuArray{Float32, 3, CUDA.DeviceMemory}, u::CuArray{Floa
t32, 4, CUDA.DeviceMemory})
    @ WaterLily ~/.julia/dev/WaterLily/src/util.jl:149
 [11] macro expansion
    @ ~/.julia/dev/WaterLily/src/util.jl:151 [inlined]
 [12] #CFL#115
    @ ~/.julia/dev/WaterLily/src/Flow.jl:169 [inlined]
 [13] CFL
    @ ~/.julia/dev/WaterLily/src/Flow.jl:168 [inlined]
 [14] mom_step!(a::Flow{3, Float32, CuArray{Float32, 3, CUDA.DeviceMemory}, CuArray{Float32, 4, CUDA.DeviceMemory}, CuArray{Float32, 5, CUDA.DeviceMemory}}, b::MultiLevelPoisson{Float32, CuArray{Float32, 3, CUDA.DeviceMemory}, CuArray{F
loat32, 4, CUDA.DeviceMemory}}; λ::Function, udf::Nothing, kwargs::@Kwargs{})
    @ WaterLily ~/.julia/dev/WaterLily/src/Flow.jl:164
 [15] sim_step!(sim::Simulation; remeasure::Bool, λ::Function, udf::Nothing, kwargs::@Kwargs{})
    @ WaterLily ~/.julia/dev/WaterLily/src/WaterLily.jl:112
 [16] sim_step!
    @ ~/.julia/dev/WaterLily/src/WaterLily.jl:110 [inlined]
 [17] sim_step!(sim::Simulation, t_end::Float32; remeasure::Bool, λ::Function, max_steps::Int64, verbose::Bool, udf::Nothing, kwargs::@Kwargs{})
    @ WaterLily ~/.julia/dev/WaterLily/src/WaterLily.jl:106
 [18] add_to_suite!(suite::BenchmarkGroup, sim_function::typeof(tgv); p::Tuple{Int64, Int64}, s::Int64, ft::Type, backend::Type, bstr::String, remeasure::Bool)
    @ Main ~/mose/waterlily/WaterLily-Benchmarks/util.jl:37
 [19] run_benchmarks(cases::Vector{String}, log2p::Vector{Tuple{Int64, Int64}}, max_steps::Vector{Int64}, ftype::Vector{DataType}, backend::Type, bstr::String; data_dir::String)
    @ Main ~/mose/waterlily/WaterLily-Benchmarks/benchmark.jl:10
 [20] top-level scope
    @ ~/mose/waterlily/WaterLily-Benchmarks/benchmark.jl:26
 [21] include(mod::Module, _path::String)
    @ Base ./Base.jl:305

To reproduce

Not very minimal, but I'm running the benchmark in https://github.com/WaterLily-jl/WaterLily-Benchmarks

Expected behavior

A clear and concise description of what you expected to happen.

Version info

Details on Julia:

julia> versioninfo()
Julia Version 1.12.0-rc2
Commit 72cbf019d04 (2025-09-06 12:00 UTC)
Build Info:
  Official https://julialang.org release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 224 × INTEL(R) XEON(R) PLATINUM 8570
  WORD_SIZE: 64
  LLVM: libLLVM-18.1.7 (ORCJIT, sapphirerapids)
  GC: Built with stock GC
Threads: 1 default, 1 interactive, 1 GC (on 224 virtual cores)

Details on CUDA:

julia> CUDA.versioninfo()
CUDA toolchain: 
- runtime 13.0, artifact installation
- driver 570.124.6 for 13.0
- compiler 13.0

CUDA libraries: 
- CUBLAS: 13.0.2
- CURAND: 10.4.0
- CUFFT: 12.0.0
- CUSOLVER: 12.0.4
- CUSPARSE: 12.6.3
- CUPTI: 2025.3.1 (API 13.0.1)
- NVML: 12.0.0+570.124.6

Julia packages: 
- CUDA: 5.9.0
- CUDA_Driver_jll: 13.0.1+0
- CUDA_Compiler_jll: 0.2.1+0
- CUDA_Runtime_jll: 0.19.1+0

Toolchain:
- Julia: 1.12.0-rc2
- LLVM: 18.1.7

8 devices:
  0: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)
  1: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)
  2: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)
  3: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)
  4: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)
  5: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)
  6: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)
  7: NVIDIA B200 (sm_100, 178.358 GiB / 179.062 GiB available)

Additional context

jl_kD4L6b8dQb.ptx.txt

[giordano]

I'm not sure how much it helps, but a minimal reproducer is

julia> using CUDA

julia> A = CUDA.rand(Float64, 1); B = CUDA.rand(Float64, 1); C = CUDA.rand(Float64, 1);

julia> C .= @fastmath max.(A, B)
ERROR: Failed to compile PTX code (ptxas exited with code 255)
Invocation arguments: --generate-line-info --verbose --gpu-name sm_100 --output-file /tmp/jl_fGL6Ta5m78.cubin /tmp/jl_bOPkHGHSrA.ptx
ptxas /tmp/jl_bOPkHGHSrA.ptx, line 72; error   : Illegal modifier '.NaN' for instruction 'max'
ptxas fatal   : Ptx assembly aborted due to errors
If you think this is a bug, please file an issue and attach /tmp/jl_bOPkHGHSrA.ptx
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:44
  [2] compile(job::GPUCompiler.CompilerJob)
    @ CUDA ~/.julia/packages/CUDA/gqNji/src/compiler/compilation.jl:356
  [3] actual_compilation(cache::Dict{…}, src::Core.MethodInstance, world::UInt64, cfg::GPUCompiler.CompilerConfig{…}, compiler::typeof(CUDA.compile), linker::typeof(CUDA.link))
    @ GPUCompiler ~/.julia/packages/GPUCompiler/Ecaql/src/execution.jl:245
  [4] cached_compilation(cache::Dict{Any, CuFunction}, src::Core.MethodInstance, cfg::GPUCompiler.CompilerConfig{GPUCompiler.PTXCompilerTarget, CUDA.CUDACompilerParams}, compiler::Function, linker::Function)
    @ GPUCompiler ~/.julia/packages/GPUCompiler/Ecaql/src/execution.jl:159
  [5] macro expansion
    @ ~/.julia/packages/CUDA/gqNji/src/compiler/execution.jl:373 [inlined]
  [6] macro expansion
    @ ./lock.jl:376 [inlined]
  [7] cufunction(f::GPUArrays.var"#gpu_broadcast_kernel_linear#_copyto!##1", tt::Type{Tuple{KernelAbstractions.CompilerMetadata{…}, CuDeviceVector{…}, Base.Broadcast.Broadcasted{…}}}; kwargs::@Kwargs{always_inline::Bool, maxthreads::Nothing})
    @ CUDA ~/.julia/packages/CUDA/gqNji/src/compiler/execution.jl:368
  [8] macro expansion
    @ ~/.julia/packages/CUDA/gqNji/src/compiler/execution.jl:112 [inlined]
  [9] (::KernelAbstractions.Kernel{…})(::CuArray{…}, ::Vararg{…}; ndrange::Tuple{…}, workgroupsize::Nothing)
    @ CUDA.CUDAKernels ~/.julia/packages/CUDA/gqNji/src/CUDAKernels.jl:124
 [10] Kernel
    @ ~/.julia/packages/CUDA/gqNji/src/CUDAKernels.jl:110 [inlined]
 [11] _copyto!
    @ ~/.julia/packages/GPUArrays/VlqUr/src/host/broadcast.jl:71 [inlined]
 [12] materialize!
    @ ~/.julia/packages/GPUArrays/VlqUr/src/host/broadcast.jl:38 [inlined]
 [13] materialize!(dest::CuArray{Float64, 1, CUDA.DeviceMemory}, bc::Base.Broadcast.Broadcasted{CUDA.CuArrayStyle{1, CUDA.DeviceMemory}, Nothing, typeof(Base.FastMath.max_fast), Tuple{CuArray{…}, CuArray{…}}})
    @ Base.Broadcast ./broadcast.jl:902
 [14] top-level scope
    @ REPL[18]:1
Some type information was truncated. Use `show(err)` to see complete types.

jl_bOPkHGHSrA.ptx.txt

[giordano]

I think this is uncovered by JuliaLang/julia#56371: if I do

diff --git a/src/device/intrinsics/math.jl b/src/device/intrinsics/math.jl
index a1d589721..6cb63b4c0 100644
--- a/src/device/intrinsics/math.jl
+++ b/src/device/intrinsics/math.jl
@@ -362,6 +362,10 @@ end
     ifelse(anynan, NaN, minval), ifelse(anynan, NaN, maxval)
 end
 
+@device_override @inline Base.FastMath.max_fast(x::T, y::T) where {T<:Union{Float32, Float64}} = ifelse(y > x, y, x)
+@device_override @inline Base.FastMath.min_fast(x::T, y::T) where {T<:Union{Float32, Float64}} = ifelse(y > x, x, y)
+@device_override @inline Base.FastMath.minmax_fast(x::T, y::T) where {T<:Union{Float32, Float64}} = ifelse(y > x, (x,y), (y,x))
+
 @device_function saturate(x::Float32) = ccall("extern __nv_saturatef", llvmcall, Cfloat, (Cfloat,), x)
 
 

then the error is gone just because we aren't calling llvm.maximum.f64 anymore:

julia> using CUDA

julia> A = CUDA.rand(Float64, 1); B = CUDA.rand(Float64, 1); C = CUDA.rand(Float64, 1);

julia> C .= @fastmath max.(A, B)
1-element CuArray{Float64, 1, CUDA.DeviceMemory}:
 0.5324164107536911

But I'm extremely confused by the error message to be honest:

	max.NaN.f64 	%fd3, %fd1, %fd2;

Based on https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-max, this is supposed to work with sm_100, right? Also, for the record

julia> run(`$(CUDA.ptxas()) --version`);
ptxas: NVIDIA (R) Ptx optimizing assembler
Copyright (c) 2005-2025 NVIDIA Corporation
Built on Wed_Jul_16_07:24:57_PM_PDT_2025
Cuda compilation tools, release 13.0, V13.0.48
Build cuda_13.0.r13.0/compiler.36260728_0

(this is coming from CUDA_Compiler_jll)

[maleadt]

Can you share the input LLVM IR? @device_code dir=... should probably work, and ptxas from CUDA_Compiler_jll should be able to reproduce this in isolation.

I haven't looked closely, but the issue is unexpected as LLVM should emit valid PTX, possibly targeting an older ISA, but AFAIK features are generally not removed by the ISA when it evolves.

[giordano]

Here's the entire output directory: device_code_fast_max.tar.gz

[giordano]

To make things even more confusing,

	max.NaN.f32 	%f3, %f1, %f2;

(@llvm.maximum.f32 in LLVM IR) can be compiled correctly. Does PTX just not support the f64 version of this instruction? max.NaN.f64 isn't mentioned explicitly in https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#floating-point-instructions-max, only the f32 version is.

device_code_fast_max.tar_f32.gz

[giordano]

Is this a bug in LLVM 18? LLVM 19 doesn't generate max.NaN.f64 anymore: https://godbolt.org/z/MKcj4Tz1E

Edit: also, for Float32 LLVM 18 generated max.NaN.f32, LLVM 19 generated code similar to what it does for Float64 (changed by llvm/llvm-project@4a8f2f2, which fixed the Float64 issue?), then LLVM 20 switched back to max.NaN.f32 (fixed by llvm/llvm-project@6f318d4?): https://godbolt.org/z/jfobK35sd 🎢

I guess this is llvm/llvm-project#64606 (comment) (but now fixed apparently), which is the only reference to the error message I got I found on the entire Internet.

[giordano]

Just to confirm this is an issue with LLVM 18-, this works out-of-the-box with Julia v1.13 (LLVM 20):

julia> using CUDA

julia> A = CUDA.rand(Float64, 1); B = CUDA.rand(Float64, 1); C = CUDA.rand(Float64, 1);

julia> C .= @fastmath max.(A, B)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from gpu_broadcast_kernel_linear with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from throw_boundserror with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_uint64 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_bool with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_int32 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from report_exception with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_float32 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_uint8 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from report_exception_name with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_uint32 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_int8 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from report_oom with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_int8 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from signal_exception with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_uint16 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_bool with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_float64 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from gc_pool_alloc with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_int64 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_float32 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_int16 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_uint32 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_int64 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_uint64 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_int32 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_uint8 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_uint16 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from box_int16 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from unbox_float64 with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from malloc with 'i32 2' from start)
warning: linking module flags 'Dwarf Version': IDs have conflicting values ('i32 4' from report_exception_frame with 'i32 2' from start)
1-element CuArray{Float64, 1, CUDA.DeviceMemory}:
 0.6791926753581379

I'm going to ignore the linking warnings, but I was impressed this didn't explode in my face in the first place 😄

Generated PTX has

$L__tmp3:
	.loc	3 171 0                         // fastmath.jl:171:0
	max.f64 	%fd3, %fd1, %fd2;

instead of max.NaN.f64 even if the LLVM IR still has

        %23 = call fast double @llvm.maximum.f64(double %21, double %22), !dbg !57

device_code_fast_max_llvm20.tar.gz

[maleadt]

Yet another argument for using the latest version of LLVM even on older Julia versions. Supposedly it should be possible to load a different libLLVM thanks to our symbol versioning, but I haven't tried this (nor will I have the time to do so anytime soon).

If you need this fixed, we could try and backport the patch to our LLVM branches. Or add special post-processing of the LLVM IR to lower the llvm.maximum differently.

I'm going to ignore the linking warnings, but I was impressed this didn't explode in my face in the first place 😄

That's fixed by JuliaLang/julia#58508, which I haven't had the time to finish.

[giordano]

If you need this fixed

For the time being, locally I'm applying

diff --git a/src/device/intrinsics/math.jl b/src/device/intrinsics/math.jl
index a1d589721..6cb63b4c0 100644
--- a/src/device/intrinsics/math.jl
+++ b/src/device/intrinsics/math.jl
@@ -362,6 +362,10 @@ end
     ifelse(anynan, NaN, minval), ifelse(anynan, NaN, maxval)
 end
 
+@device_override @inline Base.FastMath.max_fast(x::Float64, y::Float64) = ifelse(y > x, y, x)
+@device_override @inline Base.FastMath.min_fast(x::Float64, y::Float64) = ifelse(y > x, x, y)
+@device_override @inline Base.FastMath.minmax_fast(x::Float64, y::Float64) = ifelse(y > x, (x,y), (y,x))
+
 @device_function saturate(x::Float32) = ccall("extern __nv_saturatef", llvmcall, Cfloat, (Cfloat,), x)
 

Also, not urgent, I have access to this machine only for one week.