WIP: add support for working with immutables (#11902)

[Keno]

This is WIP towards #11902. Only bits tuples are supported, and this
has only so far been tested on Mac/LLVM37

[Keno]

This basically works now, but it's not particularly useful, because the intermediate ref allocation does still happen, so even something simple like

function -{N,T}(x::NTuple{N,T})
y = Ref{NTuple{N,T}}()
for i = 1:N
y[i] = -x[i]
end
y.x
end

ends up allocating. @JeffBezanson do we have anything in there right now that could deal with this?

[vtjnash]

i was expecting this to be implemented via the existing pointerref / pointerset intrinsics (possible with the addition of a new gep intrinsic). what's the rationale for adding this as a builtin function instead?

[Keno]

I was concerned about GC behavior, which is why I added a new intrinsic that atomically does this so no random pointers are flying around.

[vtjnash]

I was concerned about GC behavior, which is why I added a new intrinsic that atomically does this so no random pointers are flying around.

fair enough. a lot of the Ref code is built around late / lazy conversion to pointer under the premise that we can use that to ensure Ref ends up assigned to some local variable before having unsafe_convert called on it.

since setindex! returns the Ref, I think that ensures GC must keep it alive.

[Keno]

Except it doesn't. It returns the assigned value.

[vtjnash]

Except it doesn't. It returns the assigned value.

it isn't supposed to:

julia> x=[1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> setindex!(x, 5, 2)
3-element Array{Int64,1}:
 1
 5
 3

[Keno]

Oh, huh, why did I think it returned the assigned value?

[Keno]

Oh, yeah:

julia> a = [1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> a[1] = 2
2

[Keno]

In any case though, after inlining is the Ref still guaranteed to be live?

[vtjnash]

it doesn't really matter if it's alive or not once you've lost the reference to it, since you wouldn't be able to take the final value back out anyways

[vtjnash]

what if the base case (and new intrinsic) was offsetof, rather than mimicking GEP or the C behavior for this function.

then the implementation code could look something like:

function setindex!{T}(ref::Ref{T}, val, indices)
  ptr = unsafe_convert(::Ptr{T}, ref)
  offset = Intrinsics.offsetof(T, indices)
  unsafe_store!(ptr + offset, val)
  ref
end

[IainNZ]

(tagged 0.4.0 because underlying issue is also tagged 0.4.0)

[StefanKarpinski]

Not enough progress has been made, kicking to 1.0.

[Keno]

Superseded by #21912