Move Base.reinterpret methods to operations.jl

Author: AntonOresten

src/compiler/intrinsics/conversions.jl

@@ -152,82 +152,6 @@ function emit_intrinsic!(ctx::CGCtx, ::typeof(Intrinsics.unpack), args)
     CGVal(result_v, result_type_id, Tile{target_type, Tuple{new_n}}, new_shape)
 end
 
-# Width-convert a rank-1 tile to element type `T` (rank-1 in, rank-1 out).
-@inline function reinterpret_width(::Type{T}, flat::Tile{S}) where {T, S}
-    bs = bitwidth(S)
-    bt = bitwidth(T)
-    if bs == bt
-        return Intrinsics.bitcast(flat, T)                          # same width
-    elseif bt == 8
-        return Intrinsics.bitcast(Intrinsics.pack(flat), T)         # S → bytes → T8
-    elseif bs == 8
-        return Intrinsics.unpack(Intrinsics.bitcast(flat, UInt8), T)  # S8 → bytes → T
-    else
-        return Intrinsics.unpack(Intrinsics.pack(flat), T)          # S → bytes → T
-    end
-end
-
-# Result shape for `reinterpret(T, x)`: rescale the leading (column-major)
-# dimension by the element-width ratio, like `reinterpret(T, ::AbstractArray)`.
-@inline function reinterpret_scaled_shape(::Type{T}, ::Type{S}, sz::NTuple{N, Int}) where {T, S, N}
-    bs = bitwidth(S)
-    bt = bitwidth(T)
-    N == 0 && return ()   # 0-D: only equal-width is valid; cross-width caught at emit
-    return (fld(sz[1] * bs, bt), Base.tail(sz)...)
-end
-
-# Result shape for `reinterpret(reshape, T, x)`: drop the leading dim on widening
-# (it must equal the ratio), prepend one on narrowing, like the array version.
-@inline function reinterpret_reshape_shape(::Type{T}, ::Type{S}, sz::NTuple{N, Int}) where {T, S, N}
-    bs = bitwidth(S)
-    bt = bitwidth(T)
-    bs == bt && return sz
-    N == 0 && return ()   # cross-width on a 0-D tile is invalid; caught at emit
-    return bt > bs ? Base.tail(sz) : (div(bs, bt), sz...)
-end
-
-"""
-    Base.reinterpret(::Type{T}, x::Tile) -> Tile{T}
-
-Reinterpret the *whole tile* `x` as a tile of element type `T`, like
-`reinterpret(T, ::AbstractArray)`: the underlying bits are viewed as a contiguous
-(column-major) block and the leading dimension is rescaled by the ratio of
-element widths. Lowers to `cuda_tile.bitcast` for equal widths and to
-`cuda_tile.pack`/`unpack` (via `reshape` to rank-1) when widths differ.
-
-This is how sub-byte formats move through global memory: a `Tile{UInt8,(N,)}`
-reinterprets to a `Tile{Float4_E2M1FN,(2N,)}` and back, so FP4 data can be stored
-in a `UInt8` array. The total bit-width is preserved, so it must divide evenly.
-
-Note `reinterpret.(T, x)` (with a dot) is the unrelated *element-wise* broadcast,
-which keeps the shape and requires `T` to be the same width as `eltype(x)`.
-
-```julia
-bytes = ct.load(a, pid, (8,))                 # Tile{UInt8,(8,)}
-fp4   = reinterpret(Float4_E2M1FN, bytes)     # Tile{Float4_E2M1FN,(16,)}
-vals  = convert(ct.Tile{Float32}, fp4)        # widen for compute
-```
-"""
-@inline function Base.reinterpret(::Type{T}, x::Tile) where {T}
-    rshape = reinterpret_scaled_shape(T, eltype(x), size(x))
-    flat = Intrinsics.reshape(x, (prod(size(x)),))
-    return Intrinsics.reshape(reinterpret_width(T, flat), rshape)
-end
-
-"""
-    Base.reinterpret(reshape, ::Type{T}, x::Tile) -> Tile{T}
-
-The `reshape`-form whole-tile reinterpret, mirroring
-`reinterpret(reshape, T, ::AbstractArray)`: instead of rescaling the leading
-dimension it *removes* it when widening (the leading dim must equal
-`bitwidth(T) ÷ bitwidth(eltype(x))`) and *prepends* one when narrowing.
-"""
-@inline function Base.reinterpret(::typeof(reshape), ::Type{T}, x::Tile) where {T}
-    rshape = reinterpret_reshape_shape(T, eltype(x), size(x))
-    flat = Intrinsics.reshape(x, (prod(size(x)),))
-    return Intrinsics.reshape(reinterpret_width(T, flat), rshape)
-end
-
 """
     Intrinsics.exti(x::Tile{<:Integer}, ::Type{T}, s::Signedness.T) -> Tile{T}     where {T<:Integer}
 

src/language/operations.jl

@@ -932,6 +932,82 @@ Equivalent to single-arg `permutedims`.
     end
 end
 
+# Width-convert a rank-1 tile to element type `T` (rank-1 in, rank-1 out).
+@inline function reinterpret_width(::Type{T}, flat::Tile{S}) where {T, S}
+    bs = bitwidth(S)
+    bt = bitwidth(T)
+    if bs == bt
+        return Intrinsics.bitcast(flat, T)                          # same width
+    elseif bt == 8
+        return Intrinsics.bitcast(Intrinsics.pack(flat), T)         # S → bytes → T8
+    elseif bs == 8
+        return Intrinsics.unpack(Intrinsics.bitcast(flat, UInt8), T)  # S8 → bytes → T
+    else
+        return Intrinsics.unpack(Intrinsics.pack(flat), T)          # S → bytes → T
+    end
+end
+
+# Result shape for `reinterpret(T, x)`: rescale the leading (column-major)
+# dimension by the element-width ratio, like `reinterpret(T, ::AbstractArray)`.
+@inline function reinterpret_scaled_shape(::Type{T}, ::Type{S}, sz::NTuple{N, Int}) where {T, S, N}
+    bs = bitwidth(S)
+    bt = bitwidth(T)
+    N == 0 && return ()   # 0-D: only equal-width is valid; cross-width caught at emit
+    return (fld(sz[1] * bs, bt), Base.tail(sz)...)
+end
+
+# Result shape for `reinterpret(reshape, T, x)`: drop the leading dim on widening
+# (it must equal the ratio), prepend one on narrowing, like the array version.
+@inline function reinterpret_reshape_shape(::Type{T}, ::Type{S}, sz::NTuple{N, Int}) where {T, S, N}
+    bs = bitwidth(S)
+    bt = bitwidth(T)
+    bs == bt && return sz
+    N == 0 && return ()   # cross-width on a 0-D tile is invalid; caught at emit
+    return bt > bs ? Base.tail(sz) : (div(bs, bt), sz...)
+end
+
+"""
+    Base.reinterpret(::Type{T}, x::Tile) -> Tile{T}
+
+Reinterpret the *whole tile* `x` as a tile of element type `T`, like
+`reinterpret(T, ::AbstractArray)`: the underlying bits are viewed as a contiguous
+(column-major) block and the leading dimension is rescaled by the ratio of
+element widths. Lowers to `cuda_tile.bitcast` for equal widths and to
+`cuda_tile.pack`/`unpack` (via `reshape` to rank-1) when widths differ.
+
+This is how sub-byte formats move through global memory: a `Tile{UInt8,(N,)}`
+reinterprets to a `Tile{Float4_E2M1FN,(2N,)}` and back, so FP4 data can be stored
+in a `UInt8` array. The total bit-width is preserved, so it must divide evenly.
+
+Note `reinterpret.(T, x)` (with a dot) is the unrelated *element-wise* broadcast,
+which keeps the shape and requires `T` to be the same width as `eltype(x)`.
+
+```julia
+bytes = ct.load(a, pid, (8,))                 # Tile{UInt8,(8,)}
+fp4   = reinterpret(Float4_E2M1FN, bytes)     # Tile{Float4_E2M1FN,(16,)}
+vals  = convert(ct.Tile{Float32}, fp4)        # widen for compute
+```
+"""
+@inline function Base.reinterpret(::Type{T}, x::Tile) where {T}
+    rshape = reinterpret_scaled_shape(T, eltype(x), size(x))
+    flat = Intrinsics.reshape(x, (prod(size(x)),))
+    return Intrinsics.reshape(reinterpret_width(T, flat), rshape)
+end
+
+"""
+    Base.reinterpret(reshape, ::Type{T}, x::Tile) -> Tile{T}
+
+The `reshape`-form whole-tile reinterpret, mirroring
+`reinterpret(reshape, T, ::AbstractArray)`: instead of rescaling the leading
+dimension it *removes* it when widening (the leading dim must equal
+`bitwidth(T) ÷ bitwidth(eltype(x))`) and *prepends* one when narrowing.
+"""
+@inline function Base.reinterpret(::typeof(reshape), ::Type{T}, x::Tile) where {T}
+    rshape = reinterpret_reshape_shape(T, eltype(x), size(x))
+    flat = Intrinsics.reshape(x, (prod(size(x)),))
+    return Intrinsics.reshape(reinterpret_width(T, flat), rshape)
+end
+
 @inline Base.convert(::Type{Tile{T}}, tile::Tile{T}) where {T} = tile
 @inline Base.convert(::Type{Tile{T2}}, tile::Tile{T1, Shape}) where {T1, T2, Shape} =
     map(T2, tile)