Test source: git
Source: <stdin>
-- 1. Annotation2MetadataPass
-- 2. Annotation2MetadataPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 3. ForceFunctionAttrsPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 4. ForceFunctionAttrsPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 5. InferFunctionAttrsPass : Skipping unsupported
-- 6. InferFunctionAttrsPass : Skipping unsupported
-- 7. CoroEarlyPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 8. CoroEarlyPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 9. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 1. PassManager<Function> : Skipping NOP
-- 2. LowerExpectIntrinsicPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 3. LowerExpectIntrinsicPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 4. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 5. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 6. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 7. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = alloca i64 8, align 8
%3 = alloca i64 16, align 16
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%4 = load ptr, ptr %2, align 8
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
%7 = insertelement <4 x float> undef, float %6, i32 0
%8 = load ptr, ptr %2, align 8
%9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
%10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
%11 = insertelement <4 x float> %7, float %10, i32 1
%12 = load ptr, ptr %2, align 8
%13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
%14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
%15 = insertelement <4 x float> %11, float %14, i32 2
%16 = load ptr, ptr %2, align 8
%17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
%18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
%19 = insertelement <4 x float> %15, float %18, i32 3
store <4 x float> %19, ptr %3, align 16
%20 = load <4 x float>, ptr %3, align 16
ret <4 x float> %20
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct!
-- 8. EarlyCSEPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 9. EarlyCSEPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 10. CallSiteSplittingPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 11. CallSiteSplittingPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. LowerExpectIntrinsicPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 15. LowerExpectIntrinsicPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 16. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 17. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 18. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)
-- 19. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%V.addr = alloca i64 8, align 8
%.compoundliteral = alloca i64 16, align 16
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
start_lifetime ptr %ref.tmp
%0 = load ptr, ptr %V.addr, align 8
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%2 = extractvalue {double, double} %call, 0
store double %2, ptr %1, align 16
%3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%4 = extractvalue {double, double} %call, 1
store double %4, ptr %3, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%5 = load ptr, ptr %V.addr, align 8
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%7 = extractvalue {double, double} %call3, 0
store double %7, ptr %6, align 16
%8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%9 = extractvalue {double, double} %call3, 1
store double %9, ptr %8, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%10 = load ptr, ptr %V.addr, align 8
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%12 = extractvalue {double, double} %call8, 0
store double %12, ptr %11, align 16
%13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%14 = extractvalue {double, double} %call8, 1
store double %14, ptr %13, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%15 = load ptr, ptr %V.addr, align 8
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%17 = extractvalue {double, double} %call13, 0
store double %17, ptr %16, align 16
%18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%19 = extractvalue {double, double} %call13, 1
store double %19, ptr %18, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
%20 = load <4 x float>, ptr %.compoundliteral, align 16
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %20
}
=>
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%0 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%1 = extractvalue {double, double} %call, 0
store double %1, ptr %0, align 16
%2 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%3 = extractvalue {double, double} %call, 1
store double %3, ptr %2, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%4 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%5 = extractvalue {double, double} %call3, 0
store double %5, ptr %4, align 16
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%7 = extractvalue {double, double} %call3, 1
store double %7, ptr %6, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%8 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%9 = extractvalue {double, double} %call8, 0
store double %9, ptr %8, align 16
%10 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call8, 1
store double %11, ptr %10, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%12 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%13 = extractvalue {double, double} %call13, 0
store double %13, ptr %12, align 16
%14 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%15 = extractvalue {double, double} %call13, 1
store double %15, ptr %14, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct!
-- 20. EarlyCSEPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%0 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%1 = extractvalue {double, double} %call, 0
store double %1, ptr %0, align 16
%2 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%3 = extractvalue {double, double} %call, 1
store double %3, ptr %2, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%4 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%5 = extractvalue {double, double} %call3, 0
store double %5, ptr %4, align 16
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%7 = extractvalue {double, double} %call3, 1
store double %7, ptr %6, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%8 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%9 = extractvalue {double, double} %call8, 0
store double %9, ptr %8, align 16
%10 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call8, 1
store double %11, ptr %10, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%12 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%13 = extractvalue {double, double} %call13, 0
store double %13, ptr %12, align 16
%14 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%15 = extractvalue {double, double} %call13, 1
store double %15, ptr %14, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 21. EarlyCSEPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
%0 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
%1 = extractvalue {double, double} %call, 0
store double %1, ptr %0, align 16
%2 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
%3 = extractvalue {double, double} %call, 1
store double %3, ptr %2, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
%4 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
%5 = extractvalue {double, double} %call3, 0
store double %5, ptr %4, align 16
%6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
%7 = extractvalue {double, double} %call3, 1
store double %7, ptr %6, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
%8 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
%9 = extractvalue {double, double} %call8, 0
store double %9, ptr %8, align 16
%10 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call8, 1
store double %11, ptr %10, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
%12 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
%13 = extractvalue {double, double} %call13, 0
store double %13, ptr %12, align 16
%14 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
%15 = extractvalue {double, double} %call13, 1
store double %15, ptr %14, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
=>
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct!
-- 22. CallSiteSplittingPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 23. CallSiteSplittingPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. LowerExpectIntrinsicPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
-- 27. LowerExpectIntrinsicPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
-- 28. SimplifyCFGPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
-- 29. SimplifyCFGPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
-- 30. SROAPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)
-- 31. SROAPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval = alloca i64 16, align 16
%t.addr = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
%0 = load ptr, ptr %t.addr, align 8
memcpy ptr %retval align 16, ptr %0 align 16, i64 16
%coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
%1 = load {double, double}, ptr %coerce.dive, align 16
ret {double, double} %1
}
=>
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct!
-- 32. EarlyCSEPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 33. EarlyCSEPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 34. CallSiteSplittingPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 35. CallSiteSplittingPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. LowerExpectIntrinsicPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
-- 39. LowerExpectIntrinsicPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
-- 40. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
-- 41. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
-- 42. SROAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
Transformation seems to be correct! (syntactically equal)
-- 43. SROAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
%2 = alloca i64 8, align 8
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
%3 = load ptr, ptr %2, align 8
ret ptr %3
}
=>
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct!
-- 44. EarlyCSEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 45. EarlyCSEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 46. CallSiteSplittingPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 47. CallSiteSplittingPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. LowerExpectIntrinsicPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
-- 51. LowerExpectIntrinsicPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
-- 52. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
-- 53. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
-- 54. SROAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
Transformation seems to be correct! (syntactically equal)
-- 55. SROAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = alloca i64 8, align 8
%4 = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
store i32 noundef %1, ptr %4, align 4
%5 = load ptr, ptr %3, align 8
%6 = load i32, ptr %4, align 4
%7 = sext i32 %6 to i64
%8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
%9 = load float, ptr %8, align 4
ret float %9
}
=>
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct!
-- 56. EarlyCSEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 57. EarlyCSEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 58. CallSiteSplittingPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 59. CallSiteSplittingPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. LowerExpectIntrinsicPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 63. LowerExpectIntrinsicPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 64. SimplifyCFGPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 65. SimplifyCFGPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 66. SROAPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
Transformation seems to be correct! (syntactically equal)
-- 67. SROAPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%this.addr = alloca i64 8, align 8
%i.addr = alloca i64 4, align 4
store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
store i32 noundef %i, ptr %i.addr, align 4
%this1 = load ptr, ptr %this.addr, align 8
%0 = load i32, ptr %i.addr, align 4
%idxprom = sext i32 %0 to i64
%arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
%1 = load float, ptr %arrayidx, align 4
ret float %1
}
=>
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct!
-- 68. EarlyCSEPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 69. EarlyCSEPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 70. CallSiteSplittingPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 71. CallSiteSplittingPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 72. PassManager<Function> : Skipping NOP
-- 10. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 11. OpenMPOptPass : Skipping unsupported
-- 12. OpenMPOptPass : Skipping unsupported
-- 13. IPSCCPPass : Skipping unsupported
-- 14. IPSCCPPass : Skipping unsupported
-- 15. CalledValuePropagationPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 16. CalledValuePropagationPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 17. GlobalOptPass : Skipping unsupported
-- 18. GlobalOptPass : Skipping unsupported
-- 19. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 73. PromotePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 74. PromotePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 75. PromotePass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 76. PromotePass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 77. PromotePass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 78. PromotePass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 79. PromotePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 80. PromotePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 81. PromotePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 82. PromotePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 83. PromotePass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 84. PromotePass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 20. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 21. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 87. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i32 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i32 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i32 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i32 3
ret <4 x float> %13
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct!
-- 88. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 89. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
-- 90. PassManager<Function> : Skipping NOP
-- 91. PassManager<Function> : Skipping NOP
-- 92. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 93. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i32 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
=>
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct!
-- 94. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 95. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstCombinePass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 99. InstCombinePass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 100. SimplifyCFGPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 101. SimplifyCFGPass
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
-- 102. PassManager<Function> : Skipping NOP
-- 103. PassManager<Function> : Skipping NOP
-- 104. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 105. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 106. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 107. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 111. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 112. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 113. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 114. PassManager<Function> : Skipping NOP
-- 115. PassManager<Function> : Skipping NOP
-- 116. InstCombinePass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 117. InstCombinePass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 118. SimplifyCFGPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 119. SimplifyCFGPass
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 120. PassManager<Function> : Skipping NOP
-- 22. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 23. ModuleInlinerWrapperPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 24. RequireAnalysisPass<GlobalsAA, Module> : Skipping unsupported
-- 25. RequireAnalysisPass<GlobalsAA, Module> : Skipping unsupported
-- 26. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 121. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 122. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 123. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 124. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 125. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 126. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 127. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 128. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 129. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 130. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 131. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 132. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 27. ModuleToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 28. RequireAnalysisPass<ProfileSummaryAnalysis, Module> : Skipping NOP
-- 29. RequireAnalysisPass<ProfileSummaryAnalysis, Module> : Skipping NOP
-- 30. ModuleToPostOrderCGSCCPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 31. DevirtSCCRepeatedPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
%2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
%5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
%8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
%11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 32. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 33. InlinerPass : Skipping unsupported
-- 34. InlinerPass : Skipping unsupported
-- 35. InlinerPass : Skipping unsupported
-- 36. InlinerPass : Skipping unsupported
-- 37. PostOrderFunctionAttrsPass : Skipping unsupported
-- 38. PostOrderFunctionAttrsPass : Skipping unsupported
-- 39. ArgumentPromotionPass : Skipping unsupported
-- 40. ArgumentPromotionPass : Skipping unsupported
-- 41. OpenMPOptCGSCCPass : Skipping unsupported
-- 42. OpenMPOptCGSCCPass : Skipping unsupported
-- 43. CGSCCToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 133. PassManager<Function> : Skipping NOP
-- 134. SROAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 135. SROAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 136. EarlyCSEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 137. EarlyCSEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 138. SpeculativeExecutionPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 139. SpeculativeExecutionPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 140. JumpThreadingPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 141. JumpThreadingPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 142. CorrelatedValuePropagationPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 143. CorrelatedValuePropagationPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 144. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 145. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 146. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 147. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 148. AggressiveInstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 149. AggressiveInstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 150. LibCallsShrinkWrapPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 151. LibCallsShrinkWrapPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 152. TailCallElimPass : Skipping unsupported
-- 153. TailCallElimPass : Skipping unsupported
-- 154. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 155. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 156. ReassociatePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 157. ReassociatePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 158. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 159. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 160. FunctionToLoopPassAdaptor
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 161. PassManager<Function> : Skipping NOP
-- 162. LoopSimplifyPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 163. LoopSimplifyPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 164. LCSSAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 165. LCSSAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 166. PassManager<Function> : Skipping NOP
-- 167. FunctionToLoopPassAdaptor
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 168. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 169. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 170. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 171. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 172. FunctionToLoopPassAdaptor
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 173. PassManager<Function> : Skipping NOP
-- 174. LoopSimplifyPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 175. LoopSimplifyPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 176. LCSSAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 177. LCSSAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 178. PassManager<Function> : Skipping NOP
-- 179. FunctionToLoopPassAdaptor
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 180. SROAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 181. SROAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 182. VectorCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 183. VectorCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 184. MergedLoadStoreMotionPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 185. MergedLoadStoreMotionPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 186. GVNPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 187. GVNPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 188. SCCPPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 189. SCCPPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 190. BDCEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 191. BDCEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 192. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 193. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 194. JumpThreadingPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 195. JumpThreadingPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 196. CorrelatedValuePropagationPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 197. CorrelatedValuePropagationPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 198. ADCEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 199. ADCEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 200. MemCpyOptPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 201. MemCpyOptPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 202. DSEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 203. DSEPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 204. FunctionToLoopPassAdaptor
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 205. PassManager<Function> : Skipping NOP
-- 206. LoopSimplifyPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 207. LoopSimplifyPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 208. LCSSAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 209. LCSSAPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 210. PassManager<Function> : Skipping NOP
-- 211. FunctionToLoopPassAdaptor
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 212. CoroElidePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 213. CoroElidePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 214. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 215. SimplifyCFGPass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 216. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 217. InstCombinePass
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
-- 218. PassManager<Function> : Skipping NOP
-- 44. CGSCCToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 45. CoroSplitPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 46. CoroSplitPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 47. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 48. DevirtSCCRepeatedPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 49. DevirtSCCRepeatedPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 50. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 51. InlinerPass : Skipping unsupported
-- 52. InlinerPass : Skipping unsupported
-- 53. InlinerPass : Skipping unsupported
-- 54. InlinerPass : Skipping unsupported
-- 55. PostOrderFunctionAttrsPass : Skipping unsupported
-- 56. PostOrderFunctionAttrsPass : Skipping unsupported
-- 57. ArgumentPromotionPass : Skipping unsupported
-- 58. ArgumentPromotionPass : Skipping unsupported
-- 59. OpenMPOptCGSCCPass : Skipping unsupported
-- 60. OpenMPOptCGSCCPass : Skipping unsupported
-- 61. CGSCCToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 219. PassManager<Function> : Skipping NOP
-- 220. SROAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 221. SROAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 222. EarlyCSEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 223. EarlyCSEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 224. SpeculativeExecutionPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 225. SpeculativeExecutionPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 226. JumpThreadingPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 227. JumpThreadingPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 228. CorrelatedValuePropagationPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 229. CorrelatedValuePropagationPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 230. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 231. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 232. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 233. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 234. AggressiveInstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 235. AggressiveInstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 236. LibCallsShrinkWrapPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 237. LibCallsShrinkWrapPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 238. TailCallElimPass : Skipping unsupported
-- 239. TailCallElimPass : Skipping unsupported
-- 240. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 241. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 242. ReassociatePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 243. ReassociatePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 244. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 245. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 246. FunctionToLoopPassAdaptor
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 247. PassManager<Function> : Skipping NOP
-- 248. LoopSimplifyPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 249. LoopSimplifyPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 250. LCSSAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 251. LCSSAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 252. PassManager<Function> : Skipping NOP
-- 253. FunctionToLoopPassAdaptor
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 254. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 255. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 256. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 257. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 258. FunctionToLoopPassAdaptor
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 259. PassManager<Function> : Skipping NOP
-- 260. LoopSimplifyPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 261. LoopSimplifyPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 262. LCSSAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 263. LCSSAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 264. PassManager<Function> : Skipping NOP
-- 265. FunctionToLoopPassAdaptor
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 266. SROAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 267. SROAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 268. VectorCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 269. VectorCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 270. MergedLoadStoreMotionPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 271. MergedLoadStoreMotionPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 272. GVNPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 273. GVNPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 274. SCCPPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 275. SCCPPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 276. BDCEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 277. BDCEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 278. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 279. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 280. JumpThreadingPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 281. JumpThreadingPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 282. CorrelatedValuePropagationPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 283. CorrelatedValuePropagationPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 284. ADCEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 285. ADCEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 286. MemCpyOptPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 287. MemCpyOptPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 288. DSEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 289. DSEPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 290. FunctionToLoopPassAdaptor
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 291. PassManager<Function> : Skipping NOP
-- 292. LoopSimplifyPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 293. LoopSimplifyPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 294. LCSSAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 295. LCSSAPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 296. PassManager<Function> : Skipping NOP
-- 297. FunctionToLoopPassAdaptor
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 298. CoroElidePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 299. CoroElidePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 300. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 301. SimplifyCFGPass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 302. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 303. InstCombinePass
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
-- 304. PassManager<Function> : Skipping NOP
-- 62. CGSCCToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 63. CoroSplitPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 64. CoroSplitPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 65. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 66. DevirtSCCRepeatedPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 67. DevirtSCCRepeatedPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%2 = ptr nonnull dereferenceable(16) noundef align(16) %0
%3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
%4 = insertelement <4 x float> undef, float %3, i64 0
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%5 = ptr nonnull dereferenceable(16) noundef align(16) %0
%6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
%7 = insertelement <4 x float> %4, float %6, i64 1
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%8 = ptr nonnull dereferenceable(16) noundef align(16) %0
%9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
%10 = insertelement <4 x float> %7, float %9, i64 2
call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
%11 = ptr nonnull dereferenceable(16) noundef align(16) %0
%12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
%13 = insertelement <4 x float> %10, float %12, i64 3
ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
%3 = sext i32 noundef %1 to i64
%4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
%5 = load float, ptr %4, align 4
ret float %5
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 68. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 69. InlinerPass : Skipping unsupported
-- 70. InlinerPass : Skipping unsupported
-- 71. InlinerPass : Skipping unsupported
-- 72. InlinerPass : Skipping unsupported
-- 73. PostOrderFunctionAttrsPass : Skipping unsupported
-- 74. PostOrderFunctionAttrsPass : Skipping unsupported
-- 75. ArgumentPromotionPass : Skipping unsupported
-- 76. ArgumentPromotionPass : Skipping unsupported
-- 77. OpenMPOptCGSCCPass : Skipping unsupported
-- 78. OpenMPOptCGSCCPass : Skipping unsupported
-- 79. CGSCCToFunctionPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%11 = load float, ptr %10, align 4
%12 = insertelement <4 x float> %9, float %11, i64 3
ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
%ref.tmp = alloca i64 16, align 16, dead
%ref.tmp2 = alloca i64 16, align 16, dead
%ref.tmp7 = alloca i64 16, align 16, dead
%ref.tmp12 = alloca i64 16, align 16, dead
start_lifetime ptr %ref.tmp
%call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%0 = extractvalue {double, double} %call, 0
store double %0, ptr %ref.tmp, align 16
%1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
%2 = extractvalue {double, double} %call, 1
store double %2, ptr %1, align 8
%call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
%vecinit = insertelement <4 x float> undef, float %call1, i64 0
start_lifetime ptr %ref.tmp2
%call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%3 = extractvalue {double, double} %call3, 0
store double %3, ptr %ref.tmp2, align 16
%4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
%5 = extractvalue {double, double} %call3, 1
store double %5, ptr %4, align 8
%call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
%vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
start_lifetime ptr %ref.tmp7
%call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%6 = extractvalue {double, double} %call8, 0
store double %6, ptr %ref.tmp7, align 16
%7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
%8 = extractvalue {double, double} %call8, 1
store double %8, ptr %7, align 8
%call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
%vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
start_lifetime ptr %ref.tmp12
%call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
%9 = extractvalue {double, double} %call13, 0
store double %9, ptr %ref.tmp12, align 16
%10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
%11 = extractvalue {double, double} %call13, 1
store double %11, ptr %10, align 8
%call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
%vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
end_lifetime ptr %ref.tmp12
end_lifetime ptr %ref.tmp7
end_lifetime ptr %ref.tmp2
end_lifetime ptr %ref.tmp
ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
%retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
%retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
%retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
%.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
%.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)
----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
%idxprom = sext i32 noundef %i to i64
%arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
%0 = load float, ptr %arrayidx, align 4
ret float %0
}
Transformation seems to be correct! (syntactically equal)
-- 305. PassManager<Function> : Skipping NOP
-- 306. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%11 = load float, ptr %10, align 4
%12 = insertelement <4 x float> %9, float %11, i64 3
ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)
-- 307. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%11 = load float, ptr %10, align 4
%12 = insertelement <4 x float> %9, float %11, i64 3
ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)
-- 308. EarlyCSEPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%11 = load float, ptr %10, align 4
%12 = insertelement <4 x float> %9, float %11, i64 3
ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)
-- 309. EarlyCSEPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%11 = load float, ptr %10, align 4
%12 = insertelement <4 x float> %9, float %11, i64 3
ret <4 x float> %12
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct!
-- 310. SpeculativeExecutionPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 311. SpeculativeExecutionPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 312. JumpThreadingPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 313. JumpThreadingPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 314. CorrelatedValuePropagationPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 315. CorrelatedValuePropagationPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 316. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 317. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 318. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 319. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 4
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 4
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct!
-- 320. AggressiveInstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 321. AggressiveInstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 322. LibCallsShrinkWrapPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 323. LibCallsShrinkWrapPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 324. TailCallElimPass : Skipping unsupported
-- 325. TailCallElimPass : Skipping unsupported
-- 326. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 327. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 328. ReassociatePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 329. ReassociatePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 330. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 331. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 332. FunctionToLoopPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 333. PassManager<Function> : Skipping NOP
-- 334. LoopSimplifyPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 335. LoopSimplifyPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 336. LCSSAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 337. LCSSAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 338. PassManager<Function> : Skipping NOP
-- 339. FunctionToLoopPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 340. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 341. SimplifyCFGPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 342. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 343. InstCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 344. FunctionToLoopPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 345. PassManager<Function> : Skipping NOP
-- 346. LoopSimplifyPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 347. LoopSimplifyPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 348. LCSSAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 349. LCSSAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 350. PassManager<Function> : Skipping NOP
-- 351. FunctionToLoopPassAdaptor
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 352. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 353. SROAPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 354. VectorCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 355. VectorCombinePass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load float, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = insertelement <4 x float> undef, float %2, i64 0
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load <4 x float>, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct!
-- 356. MergedLoadStoreMotionPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load <4 x float>, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 357. MergedLoadStoreMotionPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load <4 x float>, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 358. GVNPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load <4 x float>, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)
-- 359. GVNPass
----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load <4 x float>, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
%4 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
%5 = load float, ptr %4, align 4
%6 = insertelement <4 x float> %3, float %5, i64 1
%7 = gep inbounds ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
%8 = load float, ptr %7, align 8
%9 = insertelement <4 x float> %6, float %8, i64 2
%10 = insertelement <4 x float> %9, float %8, i64 3
ret <4 x float> %10
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0) nofree noundef willreturn memory(argmem: read) {
%1:
%2 = load <4 x float>, ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0, align 16
%3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
%5 = bitcast <4 x float> %2 to i128
%6 = lshr i128 %5, 32
%7 = trunc i128 %6 to i32
%8 = bitcast i32 %7 to float
%9 = insertelement <4 x float> %3, float %8, i64 1
%11 = lshr i128 %5, 64
%12 = trunc i128 %11 to i32
%13 = bitcast i32 %12 to float
%14 = insertelement <4 x float> %9, float %13, i64 2
%15 = insertelement <4 x float> %14, float %13, i64 3
ret <4 x float> %15
}
Transformation doesn't verify! (unsound)
ERROR: Source is more defined than target
Example:
ptr nonnull nocapture nowrite dereferenceable(16) noundef align(16) %0 = pointer(non-local, block_id=0, offset=48, attrs=3)
Source:
<4 x float> %2 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >
<4 x float> %3 = < #x00000000 (+0.0), poison, poison, poison >
ptr %4 = pointer(non-local, block_id=0, offset=52, attrs=3)
float %5 = #x00000000 (+0.0)
<4 x float> %6 = < #x00000000 (+0.0), #x00000000 (+0.0), poison, poison >
ptr %7 = pointer(non-local, block_id=0, offset=56, attrs=3)
float %8 = #x00000000 (+0.0)
<4 x float> %9 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >
<4 x float> %10 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0) >
SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 > size: 128 align: 8589934592 alloc type: 0
Target:
<4 x float> %2 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >
<4 x float> %3 = < #x00000000 (+0.0), poison, poison, poison >
i128 %5 = poison
i128 %6 = poison
i32 %7 = poison
float %8 = poison
<4 x float> %9 = < #x00000000 (+0.0), poison, poison, poison >
i128 %11 = poison
i32 %12 = poison
float %13 = poison
<4 x float> %14 = < #x00000000 (+0.0), poison, poison, poison >
<4 x float> %15 = < #x00000000 (+0.0), poison, poison, poison >
Pass: GVNPass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-passes=default<O3>' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
------------------- SMT STATS -------------------
Num queries: 64
Num invalid: 0
Num skips: 0
Num trivial: 73 (53.3%)
Num timeout: 0 (0.0%)
Num errors: 0 (0.0%)
Num SAT: 40 (62.5%)
Num UNSAT: 24 (37.5%)
Alive2: Transform doesn't verify; aborting!
+ : 'RUN: at line 2' + /home/nlopes/alive2/build/opt-alive.sh '-passes=default<O3>' -S + /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/PhaseOrdering/X86/vec-load-combine.ll --check-prefix=SSE FileCheck error: '<stdin>' is empty. FileCheck command line: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/PhaseOrdering/X86/vec-load-combine.ll --check-prefix=SSE