Memory stores aren't vectorised in a `for` loop unless explicit at-inbounds is used

[giordano]

Follow up from #68 (comment):

julia> code_llvm((FixedSizeVector{Float64,Memory{Float64}},)) do v
           for idx in eachindex(v)
               v[idx] = idx
           end
       end

LLVM IR

; Function Signature: var"#23"(FixedSizeArrays.FixedSizeArray{Float64, 1, Memory{Float64}})
;  @ REPL[16]:2 within `#23`
define void @"julia_#23_3098"(ptr nocapture noundef nonnull readonly align 8 dereferenceable(16) %"v::FixedSizeArray", ptr nocapture readonly %.roots.v) #0 {
top:
; ┌ @ abstractarray.jl:321 within `eachindex`
; │┌ @ abstractarray.jl:137 within `axes1`
; ││┌ @ abstractarray.jl:98 within `axes`
; │││┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:64 within `size`
; ││││┌ @ Base.jl:49 within `getproperty`
       %0 = getelementptr inbounds i8, ptr %"v::FixedSizeArray", i64 8
; └└└└└
; ┌ @ range.jl:911 within `iterate`
; │┌ @ range.jl:688 within `isempty`
; ││┌ @ operators.jl:425 within `>`
; │││┌ @ int.jl:83 within `<`
      %.unbox = load i64, ptr %0, align 8
      %1 = icmp slt i64 %.unbox, 1
; └└└└
  br i1 %1, label %L48, label %L13.preheader16

L13.preheader16:                                  ; preds = %top
  %memoryref_mem = load ptr, ptr %.roots.v, align 8
  %memory_data_ptr = getelementptr inbounds { i64, ptr }, ptr %memoryref_mem, i64 0, i32 1
;  @ REPL[16]:3 within `#23`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:240
; │┌ @ boot.jl:544 within `memoryref`
    %memoryref_data.pre = load ptr, ptr %memory_data_ptr, align 8
; │└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:59 within `setindex!`
   br label %L29

L29:                                              ; preds = %L29, %L13.preheader16
   %value_phi3 = phi i64 [ %4, %L29 ], [ 1, %L13.preheader16 ]
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:239
; │┌ @ number.jl:7 within `convert`
; ││┌ @ float.jl:239 within `Float64`
     %2 = sitofp i64 %value_phi3 to double
; │└└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:240
   %memoryref_offset = shl i64 %value_phi3, 3
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:241
   %3 = getelementptr i8, ptr %memoryref_data.pre, i64 %memoryref_offset
   %memoryref_data6 = getelementptr i8, ptr %3, i64 -8
   store double %2, ptr %memoryref_data6, align 8
; └
;  @ REPL[16]:4 within `#23`
; ┌ @ range.jl:915 within `iterate`
   %4 = add nuw i64 %value_phi3, 1
; └
  %5 = icmp ult i64 %value_phi3, %.unbox
  br i1 %5, label %L29, label %L48

L48:                                              ; preds = %L29, %top
  ret void
}

Compare with

julia> code_llvm((FixedSizeVector{Float64,Memory{Float64}},)) do v
           for idx in eachindex(v)
               @inbounds v[idx] = idx
           end
       end

LLVM IR

; Function Signature: var"#26"(FixedSizeArrays.FixedSizeArray{Float64, 1, Memory{Float64}})
;  @ REPL[17]:2 within `#26`
define void @"julia_#26_3146"(ptr nocapture noundef nonnull readonly align 8 dereferenceable(16) %"v::FixedSizeArray", ptr nocapture readonly %.roots.v) #0 {
top:
; ┌ @ abstractarray.jl:321 within `eachindex`
; │┌ @ abstractarray.jl:137 within `axes1`
; ││┌ @ abstractarray.jl:98 within `axes`
; │││┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:64 within `size`
; ││││┌ @ Base.jl:49 within `getproperty`
       %0 = getelementptr inbounds i8, ptr %"v::FixedSizeArray", i64 8
; └└└└└
; ┌ @ range.jl:911 within `iterate`
; │┌ @ range.jl:688 within `isempty`
; ││┌ @ operators.jl:425 within `>`
; │││┌ @ int.jl:83 within `<`
      %.unbox = load i64, ptr %0, align 8
      %1 = icmp slt i64 %.unbox, 1
; └└└└
  br i1 %1, label %L48, label %L13.preheader

L13.preheader:                                    ; preds = %top
  %memoryref_mem = load ptr, ptr %.roots.v, align 8
  %memory_data_ptr = getelementptr inbounds { i64, ptr }, ptr %memoryref_mem, i64 0, i32 1
  %memoryref_data = load ptr, ptr %memory_data_ptr, align 8
;  @ REPL[17]:4 within `#26`
  %invariant.gep = getelementptr i8, ptr %memoryref_data, i64 -8
  %min.iters.check = icmp ult i64 %.unbox, 8
  br i1 %min.iters.check, label %scalar.ph, label %vector.ph

vector.ph:                                        ; preds = %L13.preheader
  %n.vec = and i64 %.unbox, 9223372036854775800
  %ind.end = or disjoint i64 %n.vec, 1
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i64> [ <i64 1, i64 2>, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %step.add = add <2 x i64> %vec.ind, <i64 2, i64 2>
  %step.add13 = add <2 x i64> %vec.ind, <i64 4, i64 4>
  %step.add14 = add <2 x i64> %vec.ind, <i64 6, i64 6>
;  @ REPL[17]:3 within `#26`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:239
; │┌ @ number.jl:7 within `convert`
; ││┌ @ float.jl:239 within `Float64`
     %2 = sitofp <2 x i64> %vec.ind to <2 x double>
     %3 = sitofp <2 x i64> %step.add to <2 x double>
     %4 = sitofp <2 x i64> %step.add13 to <2 x double>
     %5 = sitofp <2 x i64> %step.add14 to <2 x double>
; │└└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:240
   %offset.idx = shl i64 %index, 3
   %6 = or disjoint i64 %offset.idx, 8
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:241
   %7 = getelementptr i8, ptr %invariant.gep, i64 %6
   %8 = getelementptr double, ptr %7, i64 2
   %9 = getelementptr double, ptr %7, i64 4
   %10 = getelementptr double, ptr %7, i64 6
   store <2 x double> %2, ptr %7, align 8
   store <2 x double> %3, ptr %8, align 8
   store <2 x double> %4, ptr %9, align 8
   store <2 x double> %5, ptr %10, align 8
   %index.next = add nuw i64 %index, 8
   %vec.ind.next = add <2 x i64> %vec.ind, <i64 8, i64 8>
   %11 = icmp eq i64 %index.next, %n.vec
   br i1 %11, label %middle.block, label %vector.body

middle.block:                                     ; preds = %vector.body
; └
;  @ REPL[17]:4 within `#26`
  %cmp.n = icmp eq i64 %.unbox, %n.vec
  br i1 %cmp.n, label %L48, label %scalar.ph

scalar.ph:                                        ; preds = %middle.block, %L13.preheader
  %bc.resume.val = phi i64 [ %ind.end, %middle.block ], [ 1, %L13.preheader ]
  br label %L13

L13:                                              ; preds = %L13, %scalar.ph
  %value_phi3 = phi i64 [ %13, %L13 ], [ %bc.resume.val, %scalar.ph ]
;  @ REPL[17]:3 within `#26`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:239
; │┌ @ number.jl:7 within `convert`
; ││┌ @ float.jl:239 within `Float64`
     %12 = sitofp i64 %value_phi3 to double
; │└└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:240
   %memoryref_offset = shl i64 %value_phi3, 3
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:60 within `setindex!` @ genericmemory.jl:241
   %gep = getelementptr i8, ptr %invariant.gep, i64 %memoryref_offset
   store double %12, ptr %gep, align 8
; └
;  @ REPL[17]:4 within `#26`
; ┌ @ range.jl:915 within `iterate`
; │┌ @ promotion.jl:639 within `==`
    %.not.not = icmp eq i64 %value_phi3, %.unbox
; │└
   %13 = add nuw i64 %value_phi3, 1
; └
  br i1 %.not.not, label %L48, label %L13

L48:                                              ; preds = %L13, %middle.block, %top
  ret void
}

I believe this is entirely due to the fact we're using Memory instead of MemoryRef, and MemoryRef is somehow better optimised for stores (it doesn't need to call memoryrefnew(mem)). As a proof of concept (don't take this code seriously!), with this patch:

diff --git a/src/FixedSizeArrays.jl b/src/FixedSizeArrays.jl
index 6aeac57..3fd1506 100644
--- a/src/FixedSizeArrays.jl
+++ b/src/FixedSizeArrays.jl
@@ -13,9 +13,11 @@ struct Internal end
 
 struct FixedSizeArray{T,N,Mem<:GenericMemory{<:Any,T}} <: DenseArray{T,N}
     mem::Mem
+    ref::MemoryRef{T}
     size::NTuple{N,Int}
     function FixedSizeArray{T,N,M}(::Internal, mem::M, size::NTuple{N,Int}) where {T,N,M<:GenericMemory{<:Any,T}}
-        new{T,N,M}(mem, size)
+        ref = Base.memoryref(mem)
+        new{T,N,M}(mem, ref, size)
     end
 end
 
@@ -57,7 +59,7 @@ Base.IndexStyle(::Type{<:FixedSizeArray}) = IndexLinear()
 Base.@propagate_inbounds Base.getindex(A::FixedSizeArray, i::Int) = A.mem[i]
 Base.@propagate_inbounds Base.@assume_effects :noub_if_noinbounds function Base.setindex!(A::FixedSizeArray{T}, x, i::Int) where {T}
     @boundscheck checkbounds(A, i)
-    @inbounds A.mem[i] = x
+    Base.memoryrefset!(Base.memoryrefnew(A.ref, i, false), x isa T ? x : convert(T,x)::T, :not_atomic, false)
     return A
 end

I get

julia> code_llvm((FixedSizeVector{Float64,Memory{Float64}},)) do v
           for idx in eachindex(v)
               v[idx] = 1.0
           end
       end

; Function Signature: var"#2"(FixedSizeArrays.FixedSizeArray{Float64, 1, Memory{Float64}})
;  @ REPL[2]:2 within `#2`
define void @"julia_#2_2000"(ptr nocapture noundef nonnull readonly align 8 dereferenceable(32) %"v::FixedSizeArray", ptr nocapture readonly %.roots.v) #0 {
top:
; ┌ @ abstractarray.jl:321 within `eachindex`
; │┌ @ abstractarray.jl:137 within `axes1`
; ││┌ @ abstractarray.jl:98 within `axes`
; │││┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:66 within `size`
; ││││┌ @ Base.jl:49 within `getproperty`
       %0 = getelementptr inbounds i8, ptr %"v::FixedSizeArray", i64 24
; └└└└└
; ┌ @ range.jl:911 within `iterate`
; │┌ @ range.jl:688 within `isempty`
; ││┌ @ operators.jl:425 within `>`
; │││┌ @ int.jl:83 within `<`
      %.unbox = load i64, ptr %0, align 8
      %1 = icmp slt i64 %.unbox, 1
; └└└└
  br i1 %1, label %L45, label %L13.preheader14

L13.preheader14:                                  ; preds = %top
  %2 = getelementptr inbounds i8, ptr %"v::FixedSizeArray", i64 8
  %memoryref_data = load ptr, ptr %2, align 8
;  @ REPL[2]:3 within `#2`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:61 within `setindex!`
; │┌ @ abstractarray.jl:699 within `checkbounds`
    %invariant.gep = getelementptr i8, ptr %memoryref_data, i64 -8
    %min.iters.check = icmp ult i64 %.unbox, 8
    br i1 %min.iters.check, label %scalar.ph, label %vector.ph

vector.ph:                                        ; preds = %L13.preheader14
    %n.vec = and i64 %.unbox, 9223372036854775800
    %ind.end = or disjoint i64 %n.vec, 1
    br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
    %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
; │└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:62 within `setindex!`
   %offset.idx = shl i64 %index, 3
   %3 = or disjoint i64 %offset.idx, 8
   %4 = getelementptr i8, ptr %invariant.gep, i64 %3
   %5 = getelementptr i64, ptr %4, i64 2
   %6 = getelementptr i64, ptr %4, i64 4
   %7 = getelementptr i64, ptr %4, i64 6
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %4, align 8
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %5, align 8
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %6, align 8
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %7, align 8
   %index.next = add nuw i64 %index, 8
   %8 = icmp eq i64 %index.next, %n.vec
   br i1 %8, label %middle.block, label %vector.body

middle.block:                                     ; preds = %vector.body
; └
;  @ REPL[2]:4 within `#2`
  %cmp.n = icmp eq i64 %.unbox, %n.vec
  br i1 %cmp.n, label %L45, label %scalar.ph

scalar.ph:                                        ; preds = %middle.block, %L13.preheader14
  %bc.resume.val = phi i64 [ %ind.end, %middle.block ], [ 1, %L13.preheader14 ]
;  @ REPL[2]:3 within `#2`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:61 within `setindex!`
; │┌ @ abstractarray.jl:699 within `checkbounds`
    br label %L30

L30:                                              ; preds = %L30, %scalar.ph
    %value_phi3 = phi i64 [ %9, %L30 ], [ %bc.resume.val, %scalar.ph ]
; │└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArrays.jl:62 within `setindex!`
   %memoryref_offset = shl i64 %value_phi3, 3
   %gep = getelementptr i8, ptr %invariant.gep, i64 %memoryref_offset
   store i64 4607182418800017408, ptr %gep, align 8
; └
;  @ REPL[2]:4 within `#2`
; ┌ @ range.jl:915 within `iterate`
   %9 = add nuw i64 %value_phi3, 1
; └
  %10 = icmp ult i64 %value_phi3, %.unbox
  br i1 %10, label %L30, label %L45

L45:                                              ; preds = %L30, %middle.block, %top
  ret void
}

which is pretty much what you'd get for Vectors. It looks like using Memory instead of MemoryRef adds an extra layer of indirection, no idea where to go from here. CC: @oscardssmith who may have opinions about this (I already checked, JuliaLang/julia#55913 doesn't change anything here)

[giordano]

I'm so confused. On JuliaLang/julia@dc34428 I get:

julia> code_llvm((Memory{Float64},)) do v
           for idx in eachindex(v)
               v[idx] = 1.0
           end
       end

; Function Signature: var"#2"(Memory{Float64})
;  @ REPL[1]:2 within `#2`
define void @"julia_#2_1650"(ptr noundef nonnull align 8 dereferenceable(16) %"v::GenericMemory") #0 {
top:
  %pgcstack = call ptr inttoptr (i64 4335582988 to ptr)(i64 4335583024) #9
; ┌ @ range.jl:911 within `iterate`
; │┌ @ range.jl:688 within `isempty`
; ││┌ @ operators.jl:425 within `>`
; │││┌ @ int.jl:83 within `<`
      %.unbox = load i64, ptr %"v::GenericMemory", align 8
      %0 = icmp slt i64 %.unbox, 1
; └└└└
  br i1 %0, label %L29, label %mainloop

mainloop:                                         ; preds = %top
  %memory_data_ptr = getelementptr inbounds { i64, ptr }, ptr %"v::GenericMemory", i64 0, i32 1
  %memoryref_data = load ptr, ptr %memory_data_ptr, align 8
  %1 = shl nuw nsw i64 %.unbox, 1
  %memoryref_bytelen = shl i64 %.unbox, 3
;  @ REPL[1]:3 within `#2`
; ┌ @ genericmemory.jl:240 within `setindex!`
   %smin26 = call i64 @llvm.smin.i64(i64 %.unbox, i64 %1)
   %2 = sub nsw i64 %1, %smin26
   %exit.mainloop.at = call i64 @llvm.umin.i64(i64 %.unbox, i64 %2)
   %.not = icmp eq i64 %1, %smin26
   br i1 %.not, label %postloop, label %L11.preheader

L11.preheader:                                    ; preds = %mainloop
   %3 = and i64 %.unbox, 2305843009213693951
   %umax = call i64 @llvm.umax.i64(i64 %exit.mainloop.at, i64 1)
   %4 = add nsw i64 %umax, -1
   %umin = call i64 @llvm.umin.i64(i64 %3, i64 %4)
   %min.iters.check = icmp ult i64 %umin, 8
   br i1 %min.iters.check, label %scalar.ph, label %vector.ph

vector.ph:                                        ; preds = %L11.preheader
   %5 = add nuw nsw i64 %umin, 1
   %n.mod.vf = and i64 %5, 7
   %6 = icmp eq i64 %n.mod.vf, 0
   %7 = select i1 %6, i64 8, i64 %n.mod.vf
   %n.vec = sub nsw i64 %5, %7
   %ind.end = add nsw i64 %n.vec, 1
   br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
   %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
   %8 = phi i64 [ 1, %vector.ph ], [ %15, %vector.body ]
; │ @ genericmemory.jl:241 within `setindex!`
   %9 = shl i64 %8, 3
   %10 = getelementptr i8, ptr %memoryref_data, i64 %9
   %11 = getelementptr i8, ptr %10, i64 -8
   %12 = getelementptr i8, ptr %10, i64 8
   %13 = getelementptr i8, ptr %10, i64 24
   %14 = getelementptr i8, ptr %10, i64 40
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %11, align 8
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %12, align 8
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %13, align 8
   store <2 x i64> <i64 4607182418800017408, i64 4607182418800017408>, ptr %14, align 8
   %index.next = add nuw i64 %index, 8
   %15 = add i64 %8, 8
   %16 = icmp eq i64 %index.next, %n.vec
   br i1 %16, label %scalar.ph, label %vector.body

scalar.ph:                                        ; preds = %vector.body, %L11.preheader
   %bc.resume.val = phi i64 [ 1, %L11.preheader ], [ %ind.end, %vector.body ]
; │ @ genericmemory.jl:240 within `setindex!`
   br label %L11

L11:                                              ; preds = %idxend, %scalar.ph
   %value_phi3 = phi i64 [ %17, %idxend ], [ %bc.resume.val, %scalar.ph ]
   %memoryref_offset = shl i64 %value_phi3, 3
   %memoryref_byteoffset = add i64 %memoryref_offset, -8
   %memoryref_isinbounds = icmp ult i64 %memoryref_byteoffset, %memoryref_bytelen
   br i1 %memoryref_isinbounds, label %idxend, label %oob

L29:                                              ; preds = %idxend.postloop, %main.exit.selector, %top
; └
;  @ REPL[1]:4 within `#2`
  ret void

oob:                                              ; preds = %L11.postloop, %L11
  %value_phi3.lcssa = phi i64 [ %value_phi3.postloop, %L11.postloop ], [ %value_phi3, %L11 ]
;  @ REPL[1]:3 within `#2`
; ┌ @ genericmemory.jl:240 within `setindex!`
   %ptls_field = getelementptr inbounds i8, ptr %pgcstack, i64 16
   %ptls_load = load ptr, ptr %ptls_field, align 8
   %"box::GenericMemoryRef" = call noalias nonnull align 8 dereferenceable(32) ptr @ijl_gc_small_alloc(ptr %ptls_load, i32 616, i32 32, i64 4689350496) #8
   %"box::GenericMemoryRef.tag_addr" = getelementptr inbounds i64, ptr %"box::GenericMemoryRef", i64 -1
   store atomic i64 4689350496, ptr %"box::GenericMemoryRef.tag_addr" unordered, align 8
   store ptr %memoryref_data, ptr %"box::GenericMemoryRef", align 8
   %.repack17 = getelementptr inbounds { ptr, ptr }, ptr %"box::GenericMemoryRef", i64 0, i32 1
   store ptr %"v::GenericMemory", ptr %.repack17, align 8
   call void @ijl_bounds_error_int(ptr nonnull %"box::GenericMemoryRef", i64 %value_phi3.lcssa)
   unreachable

idxend:                                           ; preds = %L11
; │ @ genericmemory.jl:241 within `setindex!`
   %memoryref_data11 = getelementptr inbounds i8, ptr %memoryref_data, i64 %memoryref_byteoffset
   store i64 4607182418800017408, ptr %memoryref_data11, align 8
; └
;  @ REPL[1]:4 within `#2`
; ┌ @ range.jl:915 within `iterate`
   %17 = add nuw nsw i64 %value_phi3, 1
; └
  %.not35 = icmp ult i64 %value_phi3, %exit.mainloop.at
  br i1 %.not35, label %L11, label %main.exit.selector

main.exit.selector:                               ; preds = %idxend
  %18 = icmp ult i64 %value_phi3, %.unbox
  br i1 %18, label %postloop, label %L29

postloop:                                         ; preds = %main.exit.selector, %mainloop
  %value_phi3.copy = phi i64 [ 1, %mainloop ], [ %17, %main.exit.selector ]
  br label %L11.postloop

L11.postloop:                                     ; preds = %idxend.postloop, %postloop
  %value_phi3.postloop = phi i64 [ %20, %idxend.postloop ], [ %value_phi3.copy, %postloop ]
;  @ REPL[1]:3 within `#2`
; ┌ @ genericmemory.jl:240 within `setindex!`
   %memoryref_offset.postloop = add nsw i64 %value_phi3.postloop, -1
   %19 = add nuw nsw i64 %.unbox, %memoryref_offset.postloop
   %memoryref_ovflw.not.postloop = icmp ult i64 %19, %1
   %memoryref_byteoffset.postloop = shl i64 %memoryref_offset.postloop, 3
   %memoryref_isinbounds.postloop = icmp ult i64 %memoryref_byteoffset.postloop, %memoryref_bytelen
   %"memoryref_isinbounds&notovflw.postloop" = and i1 %memoryref_ovflw.not.postloop, %memoryref_isinbounds.postloop
   br i1 %"memoryref_isinbounds&notovflw.postloop", label %idxend.postloop, label %oob

idxend.postloop:                                  ; preds = %L11.postloop
; │ @ genericmemory.jl:241 within `setindex!`
   %memoryref_data11.postloop = getelementptr inbounds i8, ptr %memoryref_data, i64 %memoryref_byteoffset.postloop
   store i64 4607182418800017408, ptr %memoryref_data11.postloop, align 8
; └
;  @ REPL[1]:4 within `#2`
; ┌ @ range.jl:915 within `iterate`
; │┌ @ promotion.jl:639 within `==`
    %.not.not.postloop = icmp eq i64 %value_phi3.postloop, %.unbox
; │└
   %20 = add nuw nsw i64 %value_phi3.postloop, 1
; └
  br i1 %.not.not.postloop, label %L29, label %L11.postloop
}

For a plain Memory stores are vectorised (and bounds checks aren't even removed, I think it could get a similar treatment to #68), so why a thin wrapper around a Memory object can't do the same??!?

[giordano]

This issue is fixed by...reverting #68, and the solution was already in the LLVM IR shown at #65 (comment) 😕 It sounds like we can't have both bounds checking elision and vectorised stores.

[vchuravy]

That sounds like a phase ordering problem.

[giordano]

This was basically fixed on Julia v1.13 by JuliaLang/julia#57380 + JuliaLang/julia#52850:

julia> code_llvm((FixedSizeVectorDefault{Float64},)) do v
           for idx in eachindex(v)
               v[idx] = idx
           end
       end

; Function Signature: var"#2"(FixedSizeArrays.FixedSizeArray{Float64, 1, Memory{Float64}})
;  @ REPL[2]:2 within `#2`
define void @"julia_#2_1069"(ptr nocapture noundef nonnull readonly align 8 dereferenceable(16) %"v::FixedSizeArray", ptr nocapture readonly %.roots.v) local_unnamed_addr #0 {
top:
; ┌ @ abstractarray.jl:321 within `eachindex`
; │┌ @ abstractarray.jl:137 within `axes1`
; ││┌ @ abstractarray.jl:98 within `axes`
; │││┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArray.jl:137 within `size`
; ││││┌ @ Base_compiler.jl:55 within `getproperty`
       %0 = getelementptr inbounds i8, ptr %"v::FixedSizeArray", i64 8
; └└└└└
; ┌ @ range.jl:917 within `iterate`
; │┌ @ range.jl:688 within `isempty`
; ││┌ @ operators.jl:425 within `>`
; │││┌ @ int.jl:83 within `<`
      %.unbox = load i64, ptr %0, align 8
      %1 = icmp slt i64 %.unbox, 1
; └└└└
  br i1 %1, label %L49, label %L13.preheader18

L13.preheader18:                                  ; preds = %top
  %memoryref_mem = load ptr, ptr %.roots.v, align 8
  %memory_data_ptr = getelementptr inbounds { i64, ptr }, ptr %memoryref_mem, i64 0, i32 1
;  @ REPL[2]:3 within `#2`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArray.jl:133 within `setindex!` @ genericmemory.jl:260
; │┌ @ genericmemory.jl:252 within `_setindex!`
; ││┌ @ boot.jl:592 within `memoryref`
     %memoryref_data.pre = load ptr, ptr %memory_data_ptr, align 8
; └└└
;  @ REPL[2]:4 within `#2`
  %invariant.gep = getelementptr double, ptr %memoryref_data.pre, i64 -1
  %min.iters.check = icmp ult i64 %.unbox, 8
  br i1 %min.iters.check, label %L13, label %vector.ph

vector.ph:                                        ; preds = %L13.preheader18
  %n.vec = and i64 %.unbox, 9223372036854775800
  %ind.end = or disjoint i64 %n.vec, 1
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i64> [ <i64 1, i64 2>, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %step.add = add <2 x i64> %vec.ind, <i64 2, i64 2>
  %step.add19 = add <2 x i64> %vec.ind, <i64 4, i64 4>
  %step.add20 = add <2 x i64> %vec.ind, <i64 6, i64 6>
  %offset.idx = or disjoint i64 %index, 1
;  @ REPL[2]:3 within `#2`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArray.jl:133 within `setindex!` @ genericmemory.jl:259
; │┌ @ number.jl:7 within `convert`
; ││┌ @ float.jl:245 within `Float64`
     %2 = sitofp <2 x i64> %vec.ind to <2 x double>
     %3 = sitofp <2 x i64> %step.add to <2 x double>
     %4 = sitofp <2 x i64> %step.add19 to <2 x double>
     %5 = sitofp <2 x i64> %step.add20 to <2 x double>
; │└└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArray.jl:133 within `setindex!` @ genericmemory.jl:260
; │┌ @ genericmemory.jl:253 within `_setindex!`
    %6 = getelementptr double, ptr %invariant.gep, i64 %offset.idx
    %7 = getelementptr double, ptr %6, i64 2
    %8 = getelementptr double, ptr %6, i64 4
    %9 = getelementptr double, ptr %6, i64 6
    store <2 x double> %2, ptr %6, align 8
    store <2 x double> %3, ptr %7, align 8
    store <2 x double> %4, ptr %8, align 8
    store <2 x double> %5, ptr %9, align 8
    %index.next = add nuw i64 %index, 8
    %vec.ind.next = add <2 x i64> %vec.ind, <i64 8, i64 8>
    %10 = icmp eq i64 %index.next, %n.vec
    br i1 %10, label %middle.block, label %vector.body

middle.block:                                     ; preds = %vector.body
; └└
;  @ REPL[2]:4 within `#2`
  %cmp.n = icmp eq i64 %.unbox, %n.vec
  br i1 %cmp.n, label %L49, label %L13

L13:                                              ; preds = %L13, %middle.block, %L13.preheader18
  %value_phi3 = phi i64 [ %12, %L13 ], [ 1, %L13.preheader18 ], [ %ind.end, %middle.block ]
;  @ REPL[2]:3 within `#2`
; ┌ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArray.jl:133 within `setindex!` @ genericmemory.jl:259
; │┌ @ number.jl:7 within `convert`
; ││┌ @ float.jl:245 within `Float64`
     %11 = sitofp i64 %value_phi3 to double
; │└└
; │ @ /Users/mose/.julia/dev/FixedSizeArrays/src/FixedSizeArray.jl:133 within `setindex!` @ genericmemory.jl:260
; │┌ @ genericmemory.jl:253 within `_setindex!`
    %gep = getelementptr double, ptr %invariant.gep, i64 %value_phi3
    store double %11, ptr %gep, align 8
; └└
;  @ REPL[2]:4 within `#2`
; ┌ @ range.jl:921 within `iterate`
   %12 = add i64 %value_phi3, 1
; └
  %exitcond.not = icmp eq i64 %value_phi3, %.unbox
  br i1 %exitcond.not, label %L49, label %L13

L49:                                              ; preds = %L13, %middle.block, %top
  ret void
}

Contrary to what reported for Memory in JuliaLang/julia#52850 (comment), here we don't have out-of-bounds checks, the compiler was able to completely remove them.

[oscardssmith]

That's great. Thanks @gbaraldi!