Support runtime values in ct.full (Intrinsics.constant) (#100)

Co-authored-by: Tim Besard <tim.besard@gmail.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: 3 people

src/compiler/intrinsics/core.jl

@@ -181,18 +181,22 @@ function emit_intrinsic!(ctx::CGCtx, ::typeof(Intrinsics.constant), args)
     tile_shape = collect(Int, shape)
     validate_tile_shape(tile_shape, "full")
 
-    # Extract value
-    value = @something get_constant(ctx, args[2]) throw(IRError("full() value must be a compile-time constant"))
-
     # Extract dtype from Type{T} argument
     elem_type = @something get_constant(ctx, args[3]) throw(IRError("constant() requires a compile-time element type"))
 
     dtype = julia_to_tile_dtype!(tt, elem_type)
     tile_type = tile_type!(tt, dtype, tile_shape)
 
-    # Create constant directly at target shape
-    value_bytes = constant_to_bytes(value, elem_type)
-    result = encode_ConstantOp!(cb, tile_type, value_bytes)
+    tv = emit_value!(ctx, args[2])
+    tv === nothing && throw(IRError("full() value must be a constant or a runtime scalar"))
+    if tv.constant !== nothing
+        # Compile-time constant: use ConstantOp directly
+        value_bytes = constant_to_bytes(something(tv.constant), elem_type)
+        result = encode_ConstantOp!(cb, tile_type, value_bytes)
+    else
+        # Runtime value: broadcast 0D tile to the target shape
+        result = broadcast_tile_to_shape!(cb, tt, tv, tile_shape, dtype)
+    end
 
     CGVal(result, tile_type, Tile{elem_type, Tuple{tile_shape...}}, tile_shape)
 end

src/compiler/intrinsics/julia.jl

@@ -64,5 +64,5 @@ function emit_intrinsic!(ctx::CGCtx, func::Type{<:Tile}, args)
 
     # Return as 0D tile type with element type from the constructor
     result_jltype = Tile{elem_type, Tuple{}}
-    CGVal(source.v, source.type_id, result_jltype, source.shape)
+    CGVal(source.v, source.type_id, result_jltype, source.shape, nothing, source.constant, nothing)
 end

src/language/operations.jl

@@ -434,8 +434,10 @@ Create a tile filled with a constant value.
 ones_tile = ct.full((32, 32), 1.0f0, Float32)
 ```
 """
+@inline full(shape::NTuple{N, Int}, value::Tile, ::Type{T}) where {N, T} =
+    Intrinsics.constant(shape, convert(Tile{T}, value), T)
 @inline full(shape::NTuple{N, Int}, value, ::Type{T}) where {N, T} =
-    Intrinsics.constant(shape, value, T)
+    Intrinsics.constant(shape, Tile(T(value)), T)
 
 """
     zeros(shape::NTuple{N, Int}, dtype::Type{T}) -> Tile{T, shape}

test/codegen/operations.jl

@@ -428,6 +428,21 @@
             end
         end
 
+        @testset "constant with runtime value" begin
+            @test @filecheck begin
+                @check_label "entry"
+                code_tiled(Tuple{ct.TileArray{Float32,1,spec1d}, Int32}) do a, val
+                    pid = ct.bid(1)
+                    @check "itof"
+                    @check "reshape"
+                    @check "broadcast"
+                    tile = ct.full((16,), val, Float32)
+                    ct.store(a, pid, tile)
+                    return
+                end
+            end
+        end
+
         @testset "get_num_tile_blocks" begin
             @test @filecheck begin
                 @check_label "entry"

test/execution/basic.jl

@@ -1058,6 +1058,25 @@ const _EXEC_TEST_GLOBAL_CONST = Float32(1 / log(2))
     @test Array(b) ≈ Array(a) .* (scale * _EXEC_TEST_GLOBAL_CONST)
 end
 
+@testset "full with runtime value" begin
+    function full_runtime_kernel(src::ct.TileArray{Float32,1}, dst::ct.TileArray{Float32,1})
+        # Load a single-element tile to get a runtime scalar
+        val = ct.load(src, 1, (1,))
+        pid = ct.bid(1)
+        tile = ct.full((16,), val, Float32)
+        ct.store(dst, pid, tile)
+        return
+    end
+
+    n = 1024
+    src = CUDA.fill(3.14f0, 1)
+    dst = CUDA.zeros(Float32, n)
+
+    ct.launch(full_runtime_kernel, cld(n, 16), src, dst)
+
+    @test all(Array(dst) .≈ 3.14f0)
+end
+
 @testset "kernel name with !" begin
     function kernel!()
         return