1 /* Test the `vmaxnmf32' ARM Neon intrinsic. */
4 /* { dg-require-effective-target arm_v8_neon_hw } */
5 /* { dg-options "-save-temps -O3 -march=armv8-a" } */
6 /* { dg-add-options arm_v8_neon } */
12 void __attribute__ ((noinline
))
13 test_vmaxnm_f32__regular_input1 ()
15 float32_t a1
[] = {1,2};
16 float32_t b1
[] = {3,4};
17 float32x2_t a
= vld1_f32 (a1
);
18 float32x2_t b
= vld1_f32 (b1
);
19 float32x2_t c
= vmaxnm_f32 (a
, b
);
23 for (int i
= 0; i
< 2; ++i
)
24 if (actual
[i
] != b1
[i
])
28 void __attribute__ ((noinline
))
29 test_vmaxnm_f32__regular_input2 ()
31 float32_t a1
[] = {3,2};
32 float32_t b1
[] = {1,4};
33 float32_t e
[] = {3,4};
34 float32x2_t a
= vld1_f32 (a1
);
35 float32x2_t b
= vld1_f32 (b1
);
36 float32x2_t c
= vmaxnm_f32 (a
, b
);
40 for (int i
= 0; i
< 2; ++i
)
41 if (actual
[i
] != e
[i
])
45 void __attribute__ ((noinline
))
46 test_vmaxnm_f32__quiet_NaN_one_arg ()
48 /* When given a quiet NaN, vmaxnm returns the other operand.
49 In this test case we have NaNs in only one operand. */
50 float32_t n
= __builtin_nanf ("");
51 float32_t a1
[] = {1,2};
52 float32_t b1
[] = {n
,n
};
53 float32_t e
[] = {1,2};
54 float32x2_t a
= vld1_f32 (a1
);
55 float32x2_t b
= vld1_f32 (b1
);
56 float32x2_t c
= vmaxnm_f32 (a
, b
);
60 for (int i
= 0; i
< 2; ++i
)
61 if (actual
[i
] != e
[i
])
65 void __attribute__ ((noinline
))
66 test_vmaxnm_f32__quiet_NaN_both_args ()
68 /* When given a quiet NaN, vmaxnm returns the other operand.
69 In this test case we have NaNs in both operands. */
70 float32_t n
= __builtin_nanf ("");
71 float32_t a1
[] = {n
,2};
72 float32_t b1
[] = {1,n
};
73 float32_t e
[] = {1,2};
74 float32x2_t a
= vld1_f32 (a1
);
75 float32x2_t b
= vld1_f32 (b1
);
76 float32x2_t c
= vmaxnm_f32 (a
, b
);
80 for (int i
= 0; i
< 2; ++i
)
81 if (actual
[i
] != e
[i
])
85 void __attribute__ ((noinline
))
86 test_vmaxnm_f32__zero_both_args ()
88 /* For 0 and -0, vmaxnm returns 0. Since 0 == -0, check sign bit. */
89 float32_t a1
[] = {0.0, 0.0};
90 float32_t b1
[] = {-0.0, -0.0};
91 float32_t e
[] = {0.0, 0.0};
93 float32x2_t a
= vld1_f32 (a1
);
94 float32x2_t b
= vld1_f32 (b1
);
95 float32x2_t c
= vmaxnm_f32 (a
, b
);
98 vst1_f32 (actual1
, c
);
100 for (int i
= 0; i
< 2; ++i
)
101 if (actual1
[i
] != e
[i
] || __builtin_signbit (actual1
[i
]) != 0)
105 void __attribute__ ((noinline
))
106 test_vmaxnm_f32__inf_both_args ()
108 /* The max of inf and inf is inf. The max of -inf and -inf is -inf. */
109 float32_t inf
= __builtin_huge_valf ();
110 float32_t a1
[] = {inf
, -inf
};
111 float32_t b1
[] = {inf
, -inf
};
112 float32_t e
[] = {inf
, -inf
};
114 float32x2_t a
= vld1_f32 (a1
);
115 float32x2_t b
= vld1_f32 (b1
);
116 float32x2_t c
= vmaxnm_f32 (a
, b
);
118 float32_t actual1
[2];
119 vst1_f32 (actual1
, c
);
121 for (int i
= 0; i
< 2; ++i
)
122 if (actual1
[i
] != e
[i
])
126 void __attribute__ ((noinline
))
127 test_vmaxnm_f32__two_quiet_NaNs_both_args ()
129 /* When given 2 NaNs, return a NaN. Since a NaN is not equal to anything,
130 not even another NaN, use __builtin_isnan () to check. */
131 float32_t n
= __builtin_nanf ("");
132 float32_t a1
[] = {n
,n
};
133 float32_t b1
[] = {n
,n
};
134 float32_t e
[] = {n
,n
};
135 float32x2_t a
= vld1_f32 (a1
);
136 float32x2_t b
= vld1_f32 (b1
);
137 float32x2_t c
= vmaxnm_f32 (a
, b
);
139 vst1_f32 (actual
, c
);
141 for (int i
= 0; i
< 2; ++i
)
142 if (!__builtin_isnan (actual
[i
]))
149 test_vmaxnm_f32__regular_input1 ();
150 test_vmaxnm_f32__regular_input2 ();
151 test_vmaxnm_f32__quiet_NaN_one_arg ();
152 test_vmaxnm_f32__quiet_NaN_both_args ();
153 test_vmaxnm_f32__zero_both_args ();
154 test_vmaxnm_f32__inf_both_args ();
155 test_vmaxnm_f32__two_quiet_NaNs_both_args ();
159 /* { dg-final { scan-assembler-times "vmaxnm\.f32\t\[dD\]\[0-9\]+, ?\[dD\]\[0-9\]+, ?\[dD\]\[0-9\]+\n" 7 } } */