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. ConstraintEliminationPass
----------------------------------------
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. ConstraintEliminationPass
----------------------------------------
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. 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)
-- 153. 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)
-- 154. TailCallElimPass : Skipping unsupported
-- 155. TailCallElimPass : Skipping unsupported
-- 156. 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)
-- 157. 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)
-- 158. 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)
-- 159. 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)
-- 160. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 161. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 162. 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)
-- 163. PassManager<Function> : Skipping NOP
-- 164. 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)
-- 165. 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)
-- 166. 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)
-- 167. 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)
-- 168. PassManager<Function> : Skipping NOP
-- 169. 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)
-- 170. 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)
-- 171. 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)
-- 172. 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)
-- 173. 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)
-- 174. 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)
-- 175. PassManager<Function> : Skipping NOP
-- 176. 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)
-- 177. 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)
-- 178. 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)
-- 179. 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)
-- 180. PassManager<Function> : Skipping NOP
-- 181. 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)
-- 182. 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)
-- 183. 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)
-- 184. 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)
-- 185. 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)
-- 186. 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)
-- 187. 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)
-- 188. 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)
-- 189. 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)
-- 190. 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)
-- 191. 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)
-- 192. 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)
-- 193. 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)
-- 194. 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)
-- 195. 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)
-- 196. 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)
-- 197. 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)
-- 198. 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)
-- 199. 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)
-- 200. 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)
-- 201. 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)
-- 202. 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)
-- 203. 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)
-- 204. 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)
-- 205. 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)
-- 206. 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)
-- 207. PassManager<Function> : Skipping NOP
-- 208. 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)
-- 209. 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)
-- 210. 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)
-- 211. 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)
-- 212. PassManager<Function> : Skipping NOP
-- 213. 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)
-- 214. 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)
-- 215. 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)
-- 216. 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)
-- 217. 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)
-- 218. 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)
-- 219. 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)
-- 220. 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)
-- 221. PassManager<Function> : Skipping NOP
-- 222. 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)
-- 223. 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)
-- 224. 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)
-- 225. 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)
-- 226. 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)
-- 227. 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)
-- 228. 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)
-- 229. 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)
-- 230. 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)
-- 231. 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)
-- 232. 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)
-- 233. 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)
-- 234. 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)
-- 235. 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)
-- 236. 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)
-- 237. 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)
-- 238. ConstraintEliminationPass
----------------------------------------
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)
-- 239. ConstraintEliminationPass
----------------------------------------
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)
-- 240. 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)
-- 241. 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)
-- 242. TailCallElimPass : Skipping unsupported
-- 243. TailCallElimPass : Skipping unsupported
-- 244. 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)
-- 245. 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)
-- 246. 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)
-- 247. 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)
-- 248. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 249. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 250. 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)
-- 251. PassManager<Function> : Skipping NOP
-- 252. 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)
-- 253. 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)
-- 254. 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)
-- 255. 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)
-- 256. PassManager<Function> : Skipping NOP
-- 257. 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)
-- 258. 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)
-- 259. 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)
-- 260. 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)
-- 261. 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)
-- 262. 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)
-- 263. PassManager<Function> : Skipping NOP
-- 264. 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)
-- 265. 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)
-- 266. 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)
-- 267. 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)
-- 268. PassManager<Function> : Skipping NOP
-- 269. 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)
-- 270. 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)
-- 271. 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)
-- 272. 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)
-- 273. 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)
-- 274. 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)
-- 275. 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)
-- 276. 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)
-- 277. 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)
-- 278. 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)
-- 279. 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)
-- 280. 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)
-- 281. 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)
-- 282. 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)
-- 283. 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)
-- 284. 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)
-- 285. 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)
-- 286. 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)
-- 287. 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)
-- 288. 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)
-- 289. 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)
-- 290. 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)
-- 291. 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)
-- 292. 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)
-- 293. 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)
-- 294. 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)
-- 295. PassManager<Function> : Skipping NOP
-- 296. 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)
-- 297. 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)
-- 298. 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)
-- 299. 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)
-- 300. PassManager<Function> : Skipping NOP
-- 301. 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)
-- 302. 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)
-- 303. 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)
-- 304. 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)
-- 305. 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)
-- 306. 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)
-- 307. 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)
-- 308. 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)
-- 309. PassManager<Function> : Skipping NOP
-- 310. 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)
-- 311. 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)
-- 312. 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)
-- 313. 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!
-- 314. 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)
-- 315. 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)
-- 316. 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)
-- 317. 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)
-- 318. 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)
-- 319. 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)
-- 320. 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)
-- 321. 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)
-- 322. 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)
-- 323. 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!
-- 324. 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)
-- 325. 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)
-- 326. ConstraintEliminationPass
----------------------------------------
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. ConstraintEliminationPass
----------------------------------------
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. 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)
-- 329. 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)
-- 330. TailCallElimPass : Skipping unsupported
-- 331. TailCallElimPass : Skipping unsupported
-- 332. 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)
-- 333. 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)
-- 334. 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)
-- 335. 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)
-- 336. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 337. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 338. 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)
-- 339. PassManager<Function> : Skipping NOP
-- 340. 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)
-- 341. 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)
-- 342. 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)
-- 343. 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)
-- 344. PassManager<Function> : Skipping NOP
-- 345. 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)
-- 346. 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)
-- 347. 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)
-- 348. 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)
-- 349. 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)
-- 350. 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)
-- 351. PassManager<Function> : Skipping NOP
-- 352. 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)
-- 353. 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)
-- 354. 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)
-- 355. 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)
-- 356. PassManager<Function> : Skipping NOP
-- 357. 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)
-- 358. 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)
-- 359. 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)
-- 360. 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)
-- 361. 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!
-- 362. 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)
-- 363. 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)
-- 364. 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)
-- 365. 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'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_aelSf7kX_P66W.bc"
------------------- SMT STATS -------------------
Num queries: 60
Num invalid: 0
Num skips: 0
Num trivial: 77 (56.2%)
Num timeout: 0 (0.0%)
Num errors: 0 (0.0%)
Num SAT: 40 (66.7%)
Num UNSAT: 20 (33.3%)
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