Library can be loaded.

chriselrod · chriselrod · commit e4fa49eb9887 · 2020-11-25T07:04:22.000-05:00
diff --git a/Project.toml b/Project.toml
@@ -4,6 +4,7 @@ authors = ["Chris Elrod <elrodc@gmail.com>"]
 version = "0.8.26"
 
 [deps]
+ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -13,6 +14,7 @@ UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 VectorizationBase = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f"
 
 [compat]
+ArrayInterface = "2.13.7"
 DocStringExtensions = "0.8"
 IfElse = "0"
 OffsetArrays = "1"
diff --git a/src/LoopVectorization.jl b/src/LoopVectorization.jl
@@ -5,12 +5,12 @@ module LoopVectorization
 # end
 
 using VectorizationBase, SLEEFPirates, UnPack, OffsetArrays
-using VectorizationBase: REGISTER_SIZE, data,
+using VectorizationBase: REGISTER_SIZE, REGISTER_COUNT, data,
     mask, pick_vector_width_val, MM,
     maybestaticlength, maybestaticsize, staticm1, staticp1, staticmul, vzero,
     Zero, maybestaticrange, offsetprecalc,
-    maybestaticfirst, maybestaticlast, scalar_less, gesp, pointerforcomparison, NativeTypes, staticmul,
-    relu
+    maybestaticfirst, maybestaticlast, scalar_less, gep, gesp, pointerforcomparison, NativeTypes, staticmul,
+    relu, stridedpointer, StridedPointer
 using IfElse: ifelse
 
 const Static = StaticInt
@@ -29,25 +29,21 @@ import LinearAlgebra # for check_args
 
 using Base.FastMath: add_fast, sub_fast, mul_fast, div_fast
 
+using ArrayInterface
+using ArrayInterface: OptionallyStaticUnitRange, Zero
+const Static = ArrayInterface.StaticInt
+
 export LowDimArray, stridedpointer,
     @avx, @_avx, *ˡ, _avx_!,
     vmap, vmap!, vmapt, vmapt!, vmapnt, vmapnt!, vmapntt, vmapntt!,
     vfilter, vfilter!, vmapreduce, vreduce
 
-const VECTORWIDTHSYMBOL, ELTYPESYMBOL = Symbol("##Wvecwidth##"), Symbol("##Tloopeltype##")
 
-"""
-REGISTER_COUNT defined in VectorizationBase is supposed to correspond to the actual number of floating point registers on the system.
-It is hardcoded into a file at build time.
-However, someone may have multiple builds of Julia on the same system, some 32-bit and some 64-bit (e.g., they use 64-bit primarilly,
-but keep a 32-bit build on hand to debug test failures on Appveyor's 32-bit build). Thus, we don't want REGISTER_COUNT to be hardcoded
-in such a fashion. 
-32-bit builds are limited to only 8 floating point registers, so we take care of that here.
+const VECTORWIDTHSYMBOL, ELTYPESYMBOL = Symbol("##Wvecwidth##"), Symbol("##Tloopeltype##")
 
-If you want good performance, DO NOT use a 32-bit build of Julia if you don't have to.
-"""
-const REGISTER_COUNT = Sys.ARCH === :i686 ? 8 : VectorizationBase.REGISTER_COUNT
 
+include("vectorizationbase_compat/contract_pass.jl")
+include("vectorizationbase_compat/subsetview.jl")
 include("getconstindexes.jl")
 # include("vectorizationbase_extensions.jl")
 include("predicates.jl")
diff --git a/src/condense_loopset.jl b/src/condense_loopset.jl
@@ -126,11 +126,11 @@ function loop_boundary(loop::Loop)
     startexact = loop.startexact
     stopexact = loop.stopexact
     if startexact & stopexact
-        Expr(:call, Expr(:curly, lv(:StaticUnitRange), loop.starthint, loop.stophint))
+        Expr(:call, lv(:OptionallyStaticUnitRange), staticexpr(loop.starthint), staticexpr(loop.stophint))
     elseif startexact
-        Expr(:call, Expr(:curly, lv(:StaticLowerUnitRange), loop.starthint), loop.stopsym)
+        Expr(:call, lv(:OptionallyStaticUnitRange), staticexpr(loop.starthint), loop.stopsym)
     elseif stopexact
-        Expr(:call, Expr(:curly, lv(:StaticUpperUnitRange), loop.stophint), loop.startsym)
+        Expr(:call, lv(:OptionallyStaticUnitRange), loop.startsym, staticexpr(loop.stophint))
     else
         Expr(:call, :(:), loop.startsym, loop.stopsym)
     end
diff --git a/src/constructors.jl b/src/constructors.jl
@@ -57,7 +57,7 @@ end
 
 
 function LoopSet(q::Expr, mod::Symbol = :Main)
-    SIMDPirates.contract_pass!(q)
+    contract_pass!(q)
     ls = LoopSet(mod)
     copyto!(ls, q)
     resize!(ls.loop_order, num_loops(ls))
@@ -136,7 +136,7 @@ and `uᵢ=-1` disables unrolling for the correspond loop.
 
 The `@avx` macro also checks the array arguments using `LoopVectorization.check_args` to try and determine
 if they are compatible with the macro. If `check_args` returns false, a fall back loop annotated with `@inbounds`
-and `@fastmath` is generated. Note that `SIMDPirates` provides functions such as `evadd` and `evmul` that will
+and `@fastmath` is generated. Note that `VectorizationBase` provides functions such as `vadd` and `vmul` that will
 ignore `@fastmath`, preserving IEEE semantics both within `@avx` and `@fastmath`.
 `check_args` currently returns false for some wrapper types like `LinearAlgebra.UpperTriangular`, requiring you to
 use their `parent`. Triangular loops aren't yet supported.
diff --git a/src/determinestrategy.jl b/src/determinestrategy.jl
@@ -1,4 +1,6 @@
 
+const CACHELINE_SIZE = VectorizationBase.L₁CACHE.linesize
+
 # function indexappearences(op::Operation, s::Symbol)
 #     s ∉ loopdependencies(op) && return 0
 #     appearences = 0
@@ -80,7 +82,7 @@ function cost(ls::LoopSet, op::Operation, vectorized::Symbol, Wshift::Int, size_
                 #       would be nice to add a check for this CPU, to see if such a penalty is still appropriate.
                 #       Also, once more SVE (scalable vector extension) CPUs are released, would be nice to know if
                 #       this feature is common to all of them.
-                srt += 0.5VectorizationBase.REGISTER_SIZE / VectorizationBase.CACHELINE_SIZE
+                srt += 0.5VectorizationBase.REGISTER_SIZE / CACHELINE_SIZE
             end
         elseif isstore(op) # broadcast or reductionstore; if store we want to penalize reduction
             srt *= 3
@@ -469,9 +471,9 @@ function solve_unroll(
     W::Int, vectorized::Symbol, rounduᵢ::Int
 )
     (u₁step, u₂step) = if rounduᵢ == 1 # max is to safeguard against some weird arch I've never heard of.
-        (max(1,VectorizationBase.CACHELINE_SIZE ÷ VectorizationBase.REGISTER_SIZE), 1)
+        (max(1,CACHELINE_SIZE ÷ VectorizationBase.REGISTER_SIZE), 1)
     elseif rounduᵢ == 2
-        (1, max(1,VectorizationBase.CACHELINE_SIZE ÷ VectorizationBase.REGISTER_SIZE))
+        (1, max(1,CACHELINE_SIZE ÷ VectorizationBase.REGISTER_SIZE))
     else
         (1, 1)
     end
@@ -887,7 +889,7 @@ function evaluate_cost_tile(
         rt, lat, rp = cost(ls, op, vectorized, Wshift, size_T)
         if isload(op)
             if !iszero(prefetchisagoodidea(ls, op, UnrollArgs(4, unrollsyms, 4, 0)))
-                # rt += 0.5VectorizationBase.REGISTER_SIZE / VectorizationBase.CACHELINE_SIZE
+                # rt += 0.5VectorizationBase.REGISTER_SIZE / CACHELINE_SIZE
                 prefetch_good_idea = true
             end
         end
diff --git a/src/filter.jl b/src/filter.jl
@@ -12,14 +12,14 @@ if (Base.libllvm_version ≥ v"7" && VectorizationBase.AVX512F) || Base.libllvm_
             for _ ∈ 1:Nrep
                 vy = vload(Vec{W,T}, ptr_y)
                 mask = f(Vec(vy))
-                SIMDPirates.compressstore!(gep(ptr_x, j), vy, mask)
+                VectorizationBase.compressstore!(gep(ptr_x, j), vy, mask)
                 ptr_y = gepbyte(ptr_y, VectorizationBase.REGISTER_SIZE)
                 j = vadd(j, count_ones(mask))
             end
             rem_mask = VectorizationBase.mask(T, Nrem)
             vy = vload(Vec{W,T}, ptr_y, rem_mask)
             mask = rem_mask & f(Vec(vy))
-            SIMDPirates.compressstore!(gep(ptr_x, j), vy, mask)
+            VectorizationBase.compressstore!(gep(ptr_x, j), vy, mask)
             j = vadd(j, count_ones(mask))
             Base._deleteend!(x, N-j) # resize!(x, j)
         end
diff --git a/src/lower_constant.jl b/src/lower_constant.jl
@@ -70,14 +70,14 @@ function lower_constant!(
         call = if reducedchildvectorized && vectorized ∉ loopdependencies(op)
             instrclass = getparentsreductzero(ls, op)
             if instrclass == ADDITIVE_IN_REDUCTIONS
-                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:SIMDPirates)), QuoteNode(:addscalar)), Expr(:call, lv(:vzero), VECTORWIDTHSYMBOL, ELTYPESYMBOL), constsym)
+                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:addscalar)), Expr(:call, lv(:vzero), VECTORWIDTHSYMBOL, ELTYPESYMBOL), constsym)
             elseif instrclass == MULTIPLICATIVE_IN_REDUCTIONS
-                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:SIMDPirates)), QuoteNode(:mulscalar)), Expr(:call, lv(:vbroadcast), VECTORWIDTHSYMBOL, Expr(:call, :one, ELTYPESYMBOL)), constsym)
+                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:mulscalar)), Expr(:call, lv(:vbroadcast), VECTORWIDTHSYMBOL, Expr(:call, :one, ELTYPESYMBOL)), constsym)
             elseif instrclass == MAX
-                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:SIMDPirates)), QuoteNode(:maxscalar)), Expr(:call, lv(:vbroadcast), VECTORWIDTHSYMBOL, Expr(:call, :typemin, ELTYPESYMBOL)), constsym)
+                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:maxscalar)), Expr(:call, lv(:vbroadcast), VECTORWIDTHSYMBOL, Expr(:call, :typemin, ELTYPESYMBOL)), constsym)
                 
             elseif instrclass == MIN
-                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:SIMDPirates)), QuoteNode(:minscalar)), Expr(:call, lv(:vbroadcast), VECTORWIDTHSYMBOL, Expr(:call, :typemax, ELTYPESYMBOL)), constsym)
+                Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:minscalar)), Expr(:call, lv(:vbroadcast), VECTORWIDTHSYMBOL, Expr(:call, :typemax, ELTYPESYMBOL)), constsym)
                 
             else
                 throw("Reductions of type $(reduction_zero(reinstrclass)) not yet supported; please file an issue as a reminder to take care of this.")
diff --git a/src/lower_load.jl b/src/lower_load.jl
@@ -70,7 +70,7 @@ function prefetchisagoodidea(ls::LoopSet, op::Operation, td::UnrollArgs)
     length(loopdependencies(op)) ≤ 1 && return 0
     vectorized ∈ loopdependencies(op) || return 0
     u₂loopsym === Symbol("##undefined##") && return 0
-    dontskip = (VectorizationBase.CACHELINE_SIZE ÷ VectorizationBase.REGISTER_SIZE) - 1
+    dontskip = (CACHELINE_SIZE ÷ VectorizationBase.REGISTER_SIZE) - 1
     # u₂loopsym is vectorized
     # u₁vectorized = vectorized === u₁loopsym
     u₂vectorized = vectorized === u₂loopsym
diff --git a/src/lower_store.jl b/src/lower_store.jl
@@ -4,16 +4,16 @@ using VectorizationBase: vnoaliasstore!
 @inline vstoreadditivereduce!(args...) = vnoaliasstore!(args...)
 @inline vstoremultiplicativevereduce!(args...) = vnoaliasstore!(args...)
 @inline function vstoreadditivereduce!(ptr::VectorizationBase.AbstractStridedPointer, v::VectorizationBase.Vec, i::Tuple{Vararg{Union{Integer,Static}}})
-    vnoaliasstore!(ptr, SIMDPirates.vsum(v), i)
+    vnoaliasstore!(ptr, VectorizationBase.vsum(v), i)
 end
 @inline function vstoreadditivereduce!(ptr::VectorizationBase.AbstractStridedPointer, v::VectorizationBase.Vec, i::Tuple{Vararg{Union{Integer,Static}}}, m::VectorizationBase.Mask)
-    vnoaliasstore!(ptr, SIMDPirates.vsum(v), i, m)
+    vnoaliasstore!(ptr, VectorizationBase.vsum(v), i, m)
 end
 @inline function vstoremultiplicativevereduce!(ptr::VectorizationBase.AbstractStridedPointer, v::VectorizationBase.Vec, i::Tuple{Vararg{Union{Integer,Static}}})
-    vnoaliasstore!(ptr, SIMDPirates.vprod(v), i)
+    vnoaliasstore!(ptr, VectorizationBase.vprod(v), i)
 end
 @inline function vstoremultiplicativevereduce!(ptr::VectorizationBase.AbstractStridedPointer, v::VectorizationBase.Vec, i::Tuple{Vararg{Union{Integer,Static}}}, m::VectorizationBase.Mask)
-    vnoaliasstore!(ptr, SIMDPirates.vprod(v), i, m)
+    vnoaliasstore!(ptr, VectorizationBase.vprod(v), i, m)
 end
 
 function storeinstr(op::Operation, vectorized::Symbol)
diff --git a/src/lowering.jl b/src/lowering.jl
@@ -229,12 +229,12 @@ end
 # end
 
 function assume(ex)
-    Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:SIMDPirates)), QuoteNode(:assume)), ex)
+    Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:assume)), ex)
 end
 function expect(ex)
-    use_expect() || return ex
-    Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:SIMDPirates)), QuoteNode(:expect)), ex)
-    # ex
+    # use_expect() || return ex
+    # Expr(:call, Expr(:(.), Expr(:(.), :LoopVectorization, QuoteNode(:VectorizationBase)), QuoteNode(:expect)), ex)
+    ex
 end
 function loopiteratesatleastonce(loop::Loop, as::Bool = true)
     comp = if loop.startexact # requires !loop.stopexact
diff --git a/src/reconstruct_loopset.jl b/src/reconstruct_loopset.jl
@@ -10,14 +10,16 @@ function Loop(ls::LoopSet, ex::Expr, sym::Symbol, ::Type{<:AbstractUnitRange})
     pushpreamble!(ls, loopiteratesatleastonce(loop))
     loop
 end
-function Loop(ls::LoopSet, ex::Expr, sym::Symbol, ::Type{StaticUpperUnitRange{U}}) where {U}
+
+
+function Loop(ls::LoopSet, ex::Expr, sym::Symbol, ::Type{OptionallyStaticUnitRange{I, Static{U}}}) where {I<:Integer, U}
     start = gensym(String(sym)*"_loopstart")
     pushpreamble!(ls, Expr(:(=), start, Expr(:(.), ex, QuoteNode(:L))))
     loop = Loop(sym, U - 1024, U, start, Symbol(""), false, true)::Loop
     pushpreamble!(ls, loopiteratesatleastonce(loop))
     loop
 end
-function Loop(ls::LoopSet, ex::Expr, sym::Symbol, ::Type{StaticLowerUnitRange{L}}) where {L}
+function Loop(ls::LoopSet, ex::Expr, sym::Symbol, ::Type{OptionallyStaticUnitRange{Static{L}, I}}) where {I <: Integer, L}
     stop = gensym(String(sym)*"_loopstop")
     pushpreamble!(ls, Expr(:(=), stop, Expr(:(.), ex, QuoteNode(:U))))
     loop = Loop(sym, L, L + 1024, Symbol(""), stop, true, false)::Loop
@@ -31,7 +33,7 @@ end
 #     pushpreamble!(ls, Expr(:(=), stop, Expr(:call, :(+), start, N - 1)))
 #     Loop(gensym(:n), 0, N, start, stop, false, false)::Loop
 # end
-function Loop(::LoopSet, ::Expr, sym::Symbol, ::Type{StaticUnitRange{L,U}}) where {L,U}
+function Loop(::LoopSet, ::Expr, sym::Symbol, ::Type{OptionallyStaticUnitRange{Static{L}, Static{U}}}) where {L,U}
     Loop(sym, L, U, Symbol(""), Symbol(""), true, true)::Loop
 end
 
@@ -118,82 +120,45 @@ function extract_varg(i)
     sptr = Expr(:macrocall, Symbol("@inbounds"), LineNumberNode(@__LINE__, Symbol(@__FILE__)), Expr(:ref, :vargs, i))
     Base.libllvm_version ≥ v"10" ? Expr(:call, lv(:noalias!), sptr) : sptr
 end
-
-pushvarg!(ls::LoopSet, ar::ArrayReferenceMeta, i, name) = pushpreamble!(ls, Expr(:(=), name, extract_varg(i)))
-function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{S}, name
-) where {T, N, S <: AbstractColumnMajorStridedPointer{T,N}}
-    pushvarg!(ls, ar, i, name)
-end
-function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{S}, name
-) where {T, N, S <: AbstractRowMajorStridedPointer{T, N}}
-    reverse!(ar.loopedindex); reverse!(getindices(ar)); reverse!(ar.ref.offsets); # reverse the listed indices here, and transpose it to make it column major
-    pushpreamble!(ls, Expr(:(=), name, Expr(:call, lv(:transpose), extract_varg(i))))
+# _extract(::Type{Static{N}}) where {N} = N
+function pushvarg!(ls::LoopSet, ar::ArrayReferenceMeta, i, name)
+    pushpreamble!(ls, Expr(:(=), name, Expr(:call, :(VectorizationBase.zero_offsets), extract_varg(i))))
 end
 function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{S}, name
-) where {S1, S2, T, P, S <: VectorizationBase.PermutedDimsStridedPointer{S1,S2,T,P}}
-    gensymname = gensym(name)
-    li = ar.loopedindex; inds = getindices(ar); offsets = ar.ref.offsets
-    lib = copy(li); indsb = copy(inds); offsetsb = copy(offsets);
-    for i ∈ eachindex(li, inds)
-        li[i] = lib[S2[i]]
-        inds[i] = indsb[S2[i]]
-        offsets[i] = offsetsb[S2[i]]
+    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, @nospecialize(_::Type{S}), name
+) where {T, N, C, B, R, X, O, S <: StridedPointer{T,N,C,B,R,X,O}}
+    @assert B ≤ 0 "Batched arrays not supported yet."
+    sp = ArrayInterface.rank_to_sortperm(R)
+    # maybe no change needed? -- optimize common case
+    column_major = ntuple(identity, N)
+    if sp === column_major
+        return pushvarg!(ls, ar, i, name)
     end
-    add_mref!(ls, ar, i, P, gensymname)
-    pushpreamble!(ls, Expr(:(=), name, Expr(:(.), gensymname, QuoteNode(:ptr))))
-end
-function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{OffsetStridedPointer{T,N,P}}, name
-) where {T,N,P}
-    add_mref!(ls, ar, i, P, name)
-end
-function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{VectorizationBase.ZeroInitializedStridedPointer{T,P}}, name
-) where {T,P}
-    add_mref!(ls, ar, i, P, name)
-end
-function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{S}, name
-) where {T, X <: Tuple, S <: AbstractStaticStridedPointer{T,X}}
     li = ar.loopedindex; lic = copy(li);
     inds = getindices(ar); indsc = copy(inds); 
     offsets = ar.ref.offsets; offsetsc = copy(offsets);
-    Xv = Int[]; foreach(x -> push!(Xv, x), X.parameters)
-    sp = sortperm(Xv)
-    Xperm = Expr(:curly, :Tuple)
-    for (i,p) ∈ enumerate(sp)
+
+    # must now sort array's inds, and stack pointer's
+    tmpsp = gensym(name)
+    pushvarg!(ls, ar, i, tempsp)
+    # pushpreamble!(ls, 
+    strd = Expr(:tuple)
+    offsets = Expr(:tuple)
+    for (i, p) ∈ enumerate(sp)
         li[i] = lic[p]
         inds[i] = indsc[p]
         offsets[i] = offsetsc[p]
-        push!(Xperm.args, Xv[p])
-    end
-    isone(Xv[first(sp)]) || makediscontiguous!(getindices(ar))
-    ginds = Expr(:tuple); foreach(_ -> push!(ginds.args, Expr(:call, lv(:Zero))), eachindex(li))
-    sptr = if S <: VectorizationBase.StaticStridedPointer
-        Expr(:call, Expr(:curly, lv(:StaticStridedPointer), T, Xperm), Expr(:call, lv(:gep), extract_varg(i), ginds))
-    elseif S <: VectorizationBase.StaticStridedBitPointer
-        Expr(:call, Expr(:curly, lv(:StaticStridedBitPointer), Xperm), Expr(:call, lv(:gep), extract_varg(i), ginds))
-    else
-        throw("AbstractStaticStridedPointer type $S not recognized.")
+        push!(strd.args, :($tempsp.strd[$p]))
+        push!(offsets.args, :(Zero()))
+        # push!(offsets.args, :(tempsp.offsets[$p]))
     end
+    C == -1 && makediscontiguous!(getindices(ar))
+    sptype = Expr(:curly, lv(:StridedPointer), T, N, (C == -1 ? -1 : 1), 1, column_major)
+    sptr = Expr(:call, sptype, Expr(:call, :pointer, tempsp), strd, offsets)
     pushpreamble!(ls, Expr(:(=), name, sptr))
 end
-function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{S}, name
-) where {T, N, S <: AbstractSparseStridedPointer{T, N}}
-    pushvarg!(ls, ar, i, name)
-    makediscontiguous!(getindices(ar))
-end
-function add_mref!(
-    ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{VectorizationBase.MappedStridedPointer{F,T,P}}, name
-) where {F,T,P}
-    add_mref!(ls, ar, i, P, name)
-end
 function add_mref!(ls::LoopSet, ar::ArrayReferenceMeta, i::Int, ::Type{<:AbstractRange{T}}, name) where {T}
-    pushvarg!(ls, ar, i, name)
+    pushpreamble!(ls, Expr(:(=), name, extract_varg(i)))
 end
 function create_mrefs!(
     ls::LoopSet, arf::Vector{ArrayRefStruct}, as::Vector{Symbol}, os::Vector{Symbol},
@@ -404,7 +369,7 @@ function add_ops!(
 end
 
 # elbytes(::VectorizationBase.AbstractPointer{T}) where {T} = sizeof(T)::Int
-typeeltype(::Type{P}) where {T,P<:VectorizationBase.AbstractPointer{T}} = T
+typeeltype(::Type{P}) where {T,P<:VectorizationBase.AbstractStridedPointer{T}} = T
 typeeltype(::Type{<:AbstractRange{T}}) where {T} = T
 # typeeltype(::Any) = Int8
 
diff --git a/src/vectorizationbase_compat/contract_pass.jl b/src/vectorizationbase_compat/contract_pass.jl
diff --git a/src/vectorizationbase_compat/subsetview.jl b/src/vectorizationbase_compat/subsetview.jl
