WIP: Give NTuple{N, T} a layout

[Keno]

In the type system, we generally support tuples of the patter Tuple{..., Vararg{T, N}}.
However, when it comes to actually allocating these, we expand them out to
Tuple{..., T, T, T, T, T, ...}. This makes tuples not particularly suitable
as the representation for various memory buffers, because the cost of doing various
operations on their datatypes is proportional to the number of elements. This attempts
to keep them in the Vararg{T, N} form throughout the system, and similarly adding
a form of the layout specification that works for repeated trailing arguments.

Current status: Various things work, printing a tuple of this sort crashes in interesting
places. Inverse normalization (repeated trailing elements to NTuple) not yet implemented. Putting up early for feedback on the overall direction, since this involves a lot of tedious changes that I'd rather only do once.

[Keno]

Meant to make this a draft PR. Oh well.

[Keno]

Note to self. Current issue is the following subtype: Tuple{typeof(Core.Compiler.fill), Vararg{Int64, 2}} <: Tuple{typeof(Core.Compiler.fill), Any, Vararg{Union{Integer, Core.Compiler.AbstractUnitRange{T} where T}, N} where N}

[maleadt]

Would it be possible to extend this distinction to codegen, and be able to irgen both arrays and structs from tuples? This is currently dealt with somewhat automagically:

using LLVM

julia> convert(LLVMType, Tuple{Int32, Int32})
[2 x i32]

julia> convert(LLVMType, Tuple{Int32, Int64})
{ i32, i64 }

# idea: only NTuple is passed as an LLVM array
julia> convert(LLVMType, NTuple{2,Int32})
[2 x i32]

Ran into this with @jiahao trying to llvmcall a 2-register snippet of inline assembly (the same applies to ccalling the LLVM intrinsic) which returns a {i32, i32}.

[colinxs]

Just checking in to see what the timeline for something like this might be? I'm in the process of wrapping a C library which has several structs with large fields declared as inline/fixed-size arrays (e.g. int foo[10000]). My understanding is that the only way to get a Julia struct with an equivalent memory layout is to declare that field as NTuple{10000, Int} (or as an SVector), but instantiating such a gargantuan field takes an incredible amount of time. I'm hoping something like this would make working with similar structs easier (or in some cases, even possible).

[vtjnash]

Seems heavily conflicted now