Aggregate codegen errors and lower Julia throws

[maleadt]

This changes codegen to collect independent errors instead of stopping at the first one. Failed values are replaced with poison values so compilation can continue, while follow-on errors caused by those values are suppressed. The final error reports the useful root causes in source order.

It also handles Julia throw calls directly. Throws that are unavoidable become compile-time diagnostics, while throws in conditional control flow become runtime Tile IR assertions. Static exception messages are preserved when possible, and exception objects are removed before Tile IR codegen.

Taking the example from #237:

using CUDACore; import cuTile as ct

function fill_normal!(A::ct.TileArray{Float32, 1}, n::Int)
    bid = ct.bid(1)
    tile = randn(Float32, (n,))
    ct.store(A; index=bid, tile=tile)
    return
end

julia> @cuda backend=ct blocks=64 fill_normal!(CuArray{Float32}(undef, 65536), 1024)
ERROR: CodegenErrors: kernel compilation produced 2 errors:
Reason: fill() shape must be a compile-time constant
Stacktrace:
 [1] _full(value::cuTile.IntTile{Tuple{}, UInt32}, ::Type{cuTile.IntTile{Tuple{}, UInt32}}, shape::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/operations.jl:724 [inlined]
 [2] fill(v::cuTile.IntTile{Tuple{}, UInt32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/overlays.jl:164 [inlined]
 [3] randn_f32class_tile(stream::Int64, ::Type{Float32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/random.jl:427 [inlined]
 [4] randn_tile(stream::Int64, ::Type{Float32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/random.jl:486 [inlined]
 [5] randn(::Type{Float32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/random.jl:576 [inlined]
 [6] fill_normal!(A::cuTile.TileArray{Float32, 1, cuTile.ArraySpec{1, 128, true, (0,), (16,)}()}, n::Int64)
   @ Main REPL[3]:3 [inlined]

Reason: iota() shape must be a compile-time constant
Stacktrace:
 [1] counter_tile(c_base::cuTile.IntTile{Tuple{}, UInt32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/random.jl:226 [inlined]
 [2] randn_f32class_tile(stream::Int64, ::Type{Float32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/random.jl:428 [inlined]
 [3] randn_tile(stream::Int64, ::Type{Float32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/random.jl:486 [inlined]
 [4] randn(::Type{Float32}, dims::Tuple{Int64})
   @ cuTile ~/Julia/pkg/cuTile/src/language/random.jl:576 [inlined]
 [5] fill_normal!(A::cuTile.TileArray{Float32, 1, cuTile.ArraySpec{1, 128, true, (0,), (16,)}()}, n::Int64)
   @ Main REPL[3]:3 [inlined]

An unconditional throw is reported during compilation:

using CUDACore
import cuTile as ct

function unavailable_kernel()
    throw(ArgumentError("this kernel configuration is not supported"))
end

julia> @cuda backend=ct blocks=1 unavailable_kernel()
ERROR: CodegenErrors: kernel compilation produced 1 error:
Reason: this kernel configuration is not supported
Stacktrace:
 [1] unavailable_kernel()
   @ Main REPL[2]:2 [inlined]

A conditional throw is preserved as a runtime assertion:

function require_positive(n::Int)
    n > 0 || throw(ArgumentError("n must be positive"))
    return
end

julia> ct.code_tiled(require_positive, Tuple{Int})
cuda_tile.module @kernels {
  entry @require_positive(%arg0: tile<i64>, %arg1: tile<i32>) {
    %cst_0_i64 = constant <i64: 0> : tile<i64>
    %0 = cmpi less_than %cst_0_i64, %arg0, signed : tile<i64> -> tile<i1>
    if %0 {
    } else {
      %false = constant <i1: false> : tile<i1>
      assert %false, "n must be positive" : tile<i1>
    }
    return
  }
}

julia> @cuda backend=ct blocks=1 require_positive(1);

julia> @cuda backend=ct blocks=1 require_positive(-1);
REPL[9]:2: tile block: [0, 0, 0], position: []: n must be positive

[maleadt]

Errors probably can be ordered better; the randn one happens on line 3 while the Any is in a line below.