| ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6 | |
| ; RUN: opt -mtriple=aarch64-unknown-linux-gnu -vector-library=sleefgnuabi -passes=inject-tli-mappings,slp-vectorizer -S %s | FileCheck %s --check-prefixes=CHECK,SLEEF | |
| ; RUN: opt -mtriple=aarch64-unknown-linux-gnu -vector-library=ArmPL -passes=inject-tli-mappings,slp-vectorizer -S %s | FileCheck %s --check-prefixes=CHECK,ARMPL | |
| define void @sincos_f32(ptr noalias %x, ptr noalias %s, ptr noalias %c) { | |
| ; CHECK-LABEL: define void @sincos_f32( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]], ptr noalias [[C:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds float, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds float, ptr [[S]], i64 2 | |
| ; CHECK-NEXT: [[S3:%.*]] = getelementptr inbounds float, ptr [[S]], i64 3 | |
| ; CHECK-NEXT: [[C1:%.*]] = getelementptr inbounds float, ptr [[C]], i64 1 | |
| ; CHECK-NEXT: [[C2:%.*]] = getelementptr inbounds float, ptr [[C]], i64 2 | |
| ; CHECK-NEXT: [[C3:%.*]] = getelementptr inbounds float, ptr [[C]], i64 3 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X0]], ptr [[S]], ptr [[C]]) #[[ATTR0:[0-9]+]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X1]], ptr [[S1]], ptr [[C1]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X2]], ptr [[S2]], ptr [[C2]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X3]], ptr [[S3]], ptr [[C3]]) #[[ATTR0]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %s1 = getelementptr inbounds float, ptr %s, i64 1 | |
| %s2 = getelementptr inbounds float, ptr %s, i64 2 | |
| %s3 = getelementptr inbounds float, ptr %s, i64 3 | |
| %c1 = getelementptr inbounds float, ptr %c, i64 1 | |
| %c2 = getelementptr inbounds float, ptr %c, i64 2 | |
| %c3 = getelementptr inbounds float, ptr %c, i64 3 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| call void @sincosf(float %x0, ptr %s, ptr %c) #0 | |
| call void @sincosf(float %x1, ptr %s1, ptr %c1) #0 | |
| call void @sincosf(float %x2, ptr %s2, ptr %c2) #0 | |
| call void @sincosf(float %x3, ptr %s3, ptr %c3) #0 | |
| ret void | |
| } | |
| define void @sincos_f64(ptr noalias %x, ptr noalias %s, ptr noalias %c) { | |
| ; CHECK-LABEL: define void @sincos_f64( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]], ptr noalias [[C:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds double, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds double, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[C1:%.*]] = getelementptr inbounds double, ptr [[C]], i64 1 | |
| ; CHECK-NEXT: [[X0:%.*]] = load double, ptr [[X]], align 8 | |
| ; CHECK-NEXT: [[X1:%.*]] = load double, ptr [[X1P]], align 8 | |
| ; CHECK-NEXT: call void @sincos(double [[X0]], ptr [[S]], ptr [[C]]) #[[ATTR1:[0-9]+]] | |
| ; CHECK-NEXT: call void @sincos(double [[X1]], ptr [[S1]], ptr [[C1]]) #[[ATTR1]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds double, ptr %x, i64 1 | |
| %s1 = getelementptr inbounds double, ptr %s, i64 1 | |
| %c1 = getelementptr inbounds double, ptr %c, i64 1 | |
| %x0 = load double, ptr %x, align 8 | |
| %x1 = load double, ptr %x1p, align 8 | |
| call void @sincos(double %x0, ptr %s, ptr %c) #0 | |
| call void @sincos(double %x1, ptr %s1, ptr %c1) #0 | |
| ret void | |
| } | |
| define void @modf_f32(ptr noalias %x, ptr noalias %ip, ptr noalias %r) { | |
| ; CHECK-LABEL: define void @modf_f32( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[IP:%.*]], ptr noalias [[R:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[IP1:%.*]] = getelementptr inbounds float, ptr [[IP]], i64 1 | |
| ; CHECK-NEXT: [[IP2:%.*]] = getelementptr inbounds float, ptr [[IP]], i64 2 | |
| ; CHECK-NEXT: [[IP3:%.*]] = getelementptr inbounds float, ptr [[IP]], i64 3 | |
| ; CHECK-NEXT: [[R1:%.*]] = getelementptr inbounds float, ptr [[R]], i64 1 | |
| ; CHECK-NEXT: [[R2:%.*]] = getelementptr inbounds float, ptr [[R]], i64 2 | |
| ; CHECK-NEXT: [[R3:%.*]] = getelementptr inbounds float, ptr [[R]], i64 3 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: [[M0:%.*]] = call float @modff(float [[X0]], ptr [[IP]]) #[[ATTR2:[0-9]+]] | |
| ; CHECK-NEXT: [[M1:%.*]] = call float @modff(float [[X1]], ptr [[IP1]]) #[[ATTR2]] | |
| ; CHECK-NEXT: [[M2:%.*]] = call float @modff(float [[X2]], ptr [[IP2]]) #[[ATTR2]] | |
| ; CHECK-NEXT: [[M3:%.*]] = call float @modff(float [[X3]], ptr [[IP3]]) #[[ATTR2]] | |
| ; CHECK-NEXT: store float [[M0]], ptr [[R]], align 4 | |
| ; CHECK-NEXT: store float [[M1]], ptr [[R1]], align 4 | |
| ; CHECK-NEXT: store float [[M2]], ptr [[R2]], align 4 | |
| ; CHECK-NEXT: store float [[M3]], ptr [[R3]], align 4 | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %ip1 = getelementptr inbounds float, ptr %ip, i64 1 | |
| %ip2 = getelementptr inbounds float, ptr %ip, i64 2 | |
| %ip3 = getelementptr inbounds float, ptr %ip, i64 3 | |
| %r1 = getelementptr inbounds float, ptr %r, i64 1 | |
| %r2 = getelementptr inbounds float, ptr %r, i64 2 | |
| %r3 = getelementptr inbounds float, ptr %r, i64 3 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| %m0 = call float @modff(float %x0, ptr %ip) #0 | |
| %m1 = call float @modff(float %x1, ptr %ip1) #0 | |
| %m2 = call float @modff(float %x2, ptr %ip2) #0 | |
| %m3 = call float @modff(float %x3, ptr %ip3) #0 | |
| store float %m0, ptr %r, align 4 | |
| store float %m1, ptr %r1, align 4 | |
| store float %m2, ptr %r2, align 4 | |
| store float %m3, ptr %r3, align 4 | |
| ret void | |
| } | |
| ; The jumbled inputs are shuffled, the lanes of the calls keep their order. | |
| define void @modf_jumbled(ptr noalias %x, ptr noalias %ip, ptr noalias %r) { | |
| ; CHECK-LABEL: define void @modf_jumbled( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[IP:%.*]], ptr noalias [[R:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[IP1:%.*]] = getelementptr inbounds float, ptr [[IP]], i64 1 | |
| ; CHECK-NEXT: [[IP2:%.*]] = getelementptr inbounds float, ptr [[IP]], i64 2 | |
| ; CHECK-NEXT: [[IP3:%.*]] = getelementptr inbounds float, ptr [[IP]], i64 3 | |
| ; CHECK-NEXT: [[R1:%.*]] = getelementptr inbounds float, ptr [[R]], i64 1 | |
| ; CHECK-NEXT: [[R2:%.*]] = getelementptr inbounds float, ptr [[R]], i64 2 | |
| ; CHECK-NEXT: [[R3:%.*]] = getelementptr inbounds float, ptr [[R]], i64 3 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: [[M0:%.*]] = call float @modff(float [[X1]], ptr [[IP]]) #[[ATTR2]] | |
| ; CHECK-NEXT: [[M1:%.*]] = call float @modff(float [[X0]], ptr [[IP1]]) #[[ATTR2]] | |
| ; CHECK-NEXT: [[M2:%.*]] = call float @modff(float [[X3]], ptr [[IP2]]) #[[ATTR2]] | |
| ; CHECK-NEXT: [[M3:%.*]] = call float @modff(float [[X2]], ptr [[IP3]]) #[[ATTR2]] | |
| ; CHECK-NEXT: store float [[M0]], ptr [[R]], align 4 | |
| ; CHECK-NEXT: store float [[M1]], ptr [[R1]], align 4 | |
| ; CHECK-NEXT: store float [[M2]], ptr [[R2]], align 4 | |
| ; CHECK-NEXT: store float [[M3]], ptr [[R3]], align 4 | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %ip1 = getelementptr inbounds float, ptr %ip, i64 1 | |
| %ip2 = getelementptr inbounds float, ptr %ip, i64 2 | |
| %ip3 = getelementptr inbounds float, ptr %ip, i64 3 | |
| %r1 = getelementptr inbounds float, ptr %r, i64 1 | |
| %r2 = getelementptr inbounds float, ptr %r, i64 2 | |
| %r3 = getelementptr inbounds float, ptr %r, i64 3 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| %m0 = call float @modff(float %x1, ptr %ip) #0 | |
| %m1 = call float @modff(float %x0, ptr %ip1) #0 | |
| %m2 = call float @modff(float %x3, ptr %ip2) #0 | |
| %m3 = call float @modff(float %x2, ptr %ip3) #0 | |
| store float %m0, ptr %r, align 4 | |
| store float %m1, ptr %r1, align 4 | |
| store float %m2, ptr %r2, align 4 | |
| store float %m3, ptr %r3, align 4 | |
| ret void | |
| } | |
| ; Negative: errno is written. | |
| define void @sincos_errno(ptr noalias %x, ptr noalias %s, ptr noalias %c) { | |
| ; CHECK-LABEL: define void @sincos_errno( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]], ptr noalias [[C:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds float, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds float, ptr [[S]], i64 2 | |
| ; CHECK-NEXT: [[S3:%.*]] = getelementptr inbounds float, ptr [[S]], i64 3 | |
| ; CHECK-NEXT: [[C1:%.*]] = getelementptr inbounds float, ptr [[C]], i64 1 | |
| ; CHECK-NEXT: [[C2:%.*]] = getelementptr inbounds float, ptr [[C]], i64 2 | |
| ; CHECK-NEXT: [[C3:%.*]] = getelementptr inbounds float, ptr [[C]], i64 3 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X0]], ptr [[S]], ptr [[C]]) #[[ATTR3:[0-9]+]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X1]], ptr [[S1]], ptr [[C1]]) #[[ATTR3]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X2]], ptr [[S2]], ptr [[C2]]) #[[ATTR3]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X3]], ptr [[S3]], ptr [[C3]]) #[[ATTR3]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %s1 = getelementptr inbounds float, ptr %s, i64 1 | |
| %s2 = getelementptr inbounds float, ptr %s, i64 2 | |
| %s3 = getelementptr inbounds float, ptr %s, i64 3 | |
| %c1 = getelementptr inbounds float, ptr %c, i64 1 | |
| %c2 = getelementptr inbounds float, ptr %c, i64 2 | |
| %c3 = getelementptr inbounds float, ptr %c, i64 3 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| call void @sincosf(float %x0, ptr %s, ptr %c) #1 | |
| call void @sincosf(float %x1, ptr %s1, ptr %c1) #1 | |
| call void @sincosf(float %x2, ptr %s2, ptr %c2) #1 | |
| call void @sincosf(float %x3, ptr %s3, ptr %c3) #1 | |
| ret void | |
| } | |
| ; Negative: the outputs are not consecutive. | |
| define void @sincos_stride2(ptr noalias %x, ptr noalias %s, ptr noalias %c) { | |
| ; CHECK-LABEL: define void @sincos_stride2( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]], ptr noalias [[C:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds float, ptr [[S]], i64 2 | |
| ; CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds float, ptr [[S]], i64 4 | |
| ; CHECK-NEXT: [[S3:%.*]] = getelementptr inbounds float, ptr [[S]], i64 6 | |
| ; CHECK-NEXT: [[C1:%.*]] = getelementptr inbounds float, ptr [[C]], i64 2 | |
| ; CHECK-NEXT: [[C2:%.*]] = getelementptr inbounds float, ptr [[C]], i64 4 | |
| ; CHECK-NEXT: [[C3:%.*]] = getelementptr inbounds float, ptr [[C]], i64 6 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X0]], ptr [[S]], ptr [[C]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X1]], ptr [[S1]], ptr [[C1]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X2]], ptr [[S2]], ptr [[C2]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X3]], ptr [[S3]], ptr [[C3]]) #[[ATTR0]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %s1 = getelementptr inbounds float, ptr %s, i64 2 | |
| %s2 = getelementptr inbounds float, ptr %s, i64 4 | |
| %s3 = getelementptr inbounds float, ptr %s, i64 6 | |
| %c1 = getelementptr inbounds float, ptr %c, i64 2 | |
| %c2 = getelementptr inbounds float, ptr %c, i64 4 | |
| %c3 = getelementptr inbounds float, ptr %c, i64 6 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| call void @sincosf(float %x0, ptr %s, ptr %c) #0 | |
| call void @sincosf(float %x1, ptr %s1, ptr %c1) #0 | |
| call void @sincosf(float %x2, ptr %s2, ptr %c2) #0 | |
| call void @sincosf(float %x3, ptr %s3, ptr %c3) #0 | |
| ret void | |
| } | |
| ; Negative: the cosine outputs overlap the sine outputs of the next lanes. | |
| define void @sincos_overlap(ptr noalias %x, ptr noalias %s) { | |
| ; CHECK-LABEL: define void @sincos_overlap( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds float, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds float, ptr [[S]], i64 2 | |
| ; CHECK-NEXT: [[S3:%.*]] = getelementptr inbounds float, ptr [[S]], i64 3 | |
| ; CHECK-NEXT: [[S4:%.*]] = getelementptr inbounds float, ptr [[S]], i64 4 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X0]], ptr [[S]], ptr [[S1]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X1]], ptr [[S1]], ptr [[S2]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X2]], ptr [[S2]], ptr [[S3]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X3]], ptr [[S3]], ptr [[S4]]) #[[ATTR0]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %s1 = getelementptr inbounds float, ptr %s, i64 1 | |
| %s2 = getelementptr inbounds float, ptr %s, i64 2 | |
| %s3 = getelementptr inbounds float, ptr %s, i64 3 | |
| %s4 = getelementptr inbounds float, ptr %s, i64 4 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| call void @sincosf(float %x0, ptr %s, ptr %s1) #0 | |
| call void @sincosf(float %x1, ptr %s1, ptr %s2) #0 | |
| call void @sincosf(float %x2, ptr %s2, ptr %s3) #0 | |
| call void @sincosf(float %x3, ptr %s3, ptr %s4) #0 | |
| ret void | |
| } | |
| ; Negative: both outputs of a lane are the same. | |
| define void @sincos_same_out(ptr noalias %x, ptr noalias %s) { | |
| ; CHECK-LABEL: define void @sincos_same_out( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds float, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds float, ptr [[S]], i64 2 | |
| ; CHECK-NEXT: [[S3:%.*]] = getelementptr inbounds float, ptr [[S]], i64 3 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X0]], ptr [[S]], ptr [[S]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X1]], ptr [[S1]], ptr [[S1]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X2]], ptr [[S2]], ptr [[S2]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X3]], ptr [[S3]], ptr [[S3]]) #[[ATTR0]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %s1 = getelementptr inbounds float, ptr %s, i64 1 | |
| %s2 = getelementptr inbounds float, ptr %s, i64 2 | |
| %s3 = getelementptr inbounds float, ptr %s, i64 3 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| call void @sincosf(float %x0, ptr %s, ptr %s) #0 | |
| call void @sincosf(float %x1, ptr %s1, ptr %s1) #0 | |
| call void @sincosf(float %x2, ptr %s2, ptr %s2) #0 | |
| call void @sincosf(float %x3, ptr %s3, ptr %s3) #0 | |
| ret void | |
| } | |
| ; Negative: the input of a lane is the output of the previous lane. | |
| define void @sincos_chain(ptr noalias %s, ptr noalias %c) { | |
| ; CHECK-LABEL: define void @sincos_chain( | |
| ; CHECK-SAME: ptr noalias [[S:%.*]], ptr noalias [[C:%.*]]) { | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds float, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds float, ptr [[S]], i64 2 | |
| ; CHECK-NEXT: [[S3:%.*]] = getelementptr inbounds float, ptr [[S]], i64 3 | |
| ; CHECK-NEXT: [[S4:%.*]] = getelementptr inbounds float, ptr [[S]], i64 4 | |
| ; CHECK-NEXT: [[C1:%.*]] = getelementptr inbounds float, ptr [[C]], i64 1 | |
| ; CHECK-NEXT: [[C2:%.*]] = getelementptr inbounds float, ptr [[C]], i64 2 | |
| ; CHECK-NEXT: [[C3:%.*]] = getelementptr inbounds float, ptr [[C]], i64 3 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[S]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X0]], ptr [[S1]], ptr [[C]]) #[[ATTR0]] | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[S1]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X1]], ptr [[S2]], ptr [[C1]]) #[[ATTR0]] | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[S2]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X2]], ptr [[S3]], ptr [[C2]]) #[[ATTR0]] | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[S3]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X3]], ptr [[S4]], ptr [[C3]]) #[[ATTR0]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %s1 = getelementptr inbounds float, ptr %s, i64 1 | |
| %s2 = getelementptr inbounds float, ptr %s, i64 2 | |
| %s3 = getelementptr inbounds float, ptr %s, i64 3 | |
| %s4 = getelementptr inbounds float, ptr %s, i64 4 | |
| %c1 = getelementptr inbounds float, ptr %c, i64 1 | |
| %c2 = getelementptr inbounds float, ptr %c, i64 2 | |
| %c3 = getelementptr inbounds float, ptr %c, i64 3 | |
| %x0 = load float, ptr %s, align 4 | |
| call void @sincosf(float %x0, ptr %s1, ptr %c) #0 | |
| %x1 = load float, ptr %s1, align 4 | |
| call void @sincosf(float %x1, ptr %s2, ptr %c1) #0 | |
| %x2 = load float, ptr %s2, align 4 | |
| call void @sincosf(float %x2, ptr %s3, ptr %c2) #0 | |
| %x3 = load float, ptr %s3, align 4 | |
| call void @sincosf(float %x3, ptr %s4, ptr %c3) #0 | |
| ret void | |
| } | |
| ; Negative: the lanes go in the reverse memory order. | |
| define void @sincos_reverse(ptr noalias %x, ptr noalias %s, ptr noalias %c) { | |
| ; CHECK-LABEL: define void @sincos_reverse( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]], ptr noalias [[C:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[X2P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 2 | |
| ; CHECK-NEXT: [[X3P:%.*]] = getelementptr inbounds float, ptr [[X]], i64 3 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds float, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds float, ptr [[S]], i64 2 | |
| ; CHECK-NEXT: [[S3:%.*]] = getelementptr inbounds float, ptr [[S]], i64 3 | |
| ; CHECK-NEXT: [[C1:%.*]] = getelementptr inbounds float, ptr [[C]], i64 1 | |
| ; CHECK-NEXT: [[C2:%.*]] = getelementptr inbounds float, ptr [[C]], i64 2 | |
| ; CHECK-NEXT: [[C3:%.*]] = getelementptr inbounds float, ptr [[C]], i64 3 | |
| ; CHECK-NEXT: [[X0:%.*]] = load float, ptr [[X]], align 4 | |
| ; CHECK-NEXT: [[X1:%.*]] = load float, ptr [[X1P]], align 4 | |
| ; CHECK-NEXT: [[X2:%.*]] = load float, ptr [[X2P]], align 4 | |
| ; CHECK-NEXT: [[X3:%.*]] = load float, ptr [[X3P]], align 4 | |
| ; CHECK-NEXT: call void @sincosf(float [[X3]], ptr [[S3]], ptr [[C3]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X2]], ptr [[S2]], ptr [[C2]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X1]], ptr [[S1]], ptr [[C1]]) #[[ATTR0]] | |
| ; CHECK-NEXT: call void @sincosf(float [[X0]], ptr [[S]], ptr [[C]]) #[[ATTR0]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds float, ptr %x, i64 1 | |
| %x2p = getelementptr inbounds float, ptr %x, i64 2 | |
| %x3p = getelementptr inbounds float, ptr %x, i64 3 | |
| %s1 = getelementptr inbounds float, ptr %s, i64 1 | |
| %s2 = getelementptr inbounds float, ptr %s, i64 2 | |
| %s3 = getelementptr inbounds float, ptr %s, i64 3 | |
| %c1 = getelementptr inbounds float, ptr %c, i64 1 | |
| %c2 = getelementptr inbounds float, ptr %c, i64 2 | |
| %c3 = getelementptr inbounds float, ptr %c, i64 3 | |
| %x0 = load float, ptr %x, align 4 | |
| %x1 = load float, ptr %x1p, align 4 | |
| %x2 = load float, ptr %x2p, align 4 | |
| %x3 = load float, ptr %x3p, align 4 | |
| call void @sincosf(float %x3, ptr %s3, ptr %c3) #0 | |
| call void @sincosf(float %x2, ptr %s2, ptr %c2) #0 | |
| call void @sincosf(float %x1, ptr %s1, ptr %c1) #0 | |
| call void @sincosf(float %x0, ptr %s, ptr %c) #0 | |
| ret void | |
| } | |
| ; Negative: the results of the first call must not be written after the release | |
| ; store. | |
| define void @sincos_atomic(ptr noalias %x, ptr noalias %s, ptr noalias %c, ptr noalias %g) { | |
| ; CHECK-LABEL: define void @sincos_atomic( | |
| ; CHECK-SAME: ptr noalias [[X:%.*]], ptr noalias [[S:%.*]], ptr noalias [[C:%.*]], ptr noalias [[G:%.*]]) { | |
| ; CHECK-NEXT: [[X1P:%.*]] = getelementptr inbounds double, ptr [[X]], i64 1 | |
| ; CHECK-NEXT: [[S1:%.*]] = getelementptr inbounds double, ptr [[S]], i64 1 | |
| ; CHECK-NEXT: [[C1:%.*]] = getelementptr inbounds double, ptr [[C]], i64 1 | |
| ; CHECK-NEXT: [[X0:%.*]] = load double, ptr [[X]], align 8 | |
| ; CHECK-NEXT: [[X1:%.*]] = load double, ptr [[X1P]], align 8 | |
| ; CHECK-NEXT: call void @sincos(double [[X0]], ptr [[S]], ptr [[C]]) #[[ATTR1]] | |
| ; CHECK-NEXT: store atomic i32 1, ptr [[G]] release, align 4 | |
| ; CHECK-NEXT: call void @sincos(double [[X1]], ptr [[S1]], ptr [[C1]]) #[[ATTR1]] | |
| ; CHECK-NEXT: ret void | |
| ; | |
| %x1p = getelementptr inbounds double, ptr %x, i64 1 | |
| %s1 = getelementptr inbounds double, ptr %s, i64 1 | |
| %c1 = getelementptr inbounds double, ptr %c, i64 1 | |
| %x0 = load double, ptr %x, align 8 | |
| %x1 = load double, ptr %x1p, align 8 | |
| call void @sincos(double %x0, ptr %s, ptr %c) #0 | |
| store atomic i32 1, ptr %g release, align 4 | |
| call void @sincos(double %x1, ptr %s1, ptr %c1) #0 | |
| ret void | |
| } | |
| declare void @sincosf(float, ptr, ptr) | |
| declare void @sincos(double, ptr, ptr) | |
| declare float @modff(float, ptr) | |
| attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: write) } | |
| attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: write, errnomem: write) } | |
| ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: | |
| ; ARMPL: {{.*}} | |
| ; SLEEF: {{.*}} |