| 1 |
/* { dg-do run } */ |
| 2 |
/* { dg-require-effective-target p8vector_hw } */ |
| 3 |
/* { dg-require-effective-target int128 } */ |
| 4 |
/* { dg-options "-mdejagnu-cpu=power8 -O3" } */ |
| 5 |
|
| 6 |
#include <altivec.h> |
| 7 |
|
| 8 |
#ifdef DEBUG |
| 9 |
#include <stdio.h> |
| 10 |
#endif |
| 11 |
|
| 12 |
void abort (void); |
| 13 |
|
| 14 |
/* Verify vec_revb builtins */ |
| 15 |
|
| 16 |
int |
| 17 |
main() |
| 18 |
{ |
| 19 |
int i; |
| 20 |
vector bool char arg_bc, result_bc, expected_bc; |
| 21 |
vector unsigned char arg_uc, result_uc, expected_uc; |
| 22 |
vector signed char arg_sc, result_sc, expected_sc; |
| 23 |
|
| 24 |
vector bool short int arg_bsi, result_bsi, expected_bsi; |
| 25 |
vector unsigned short int arg_usi, result_usi, expected_usi; |
| 26 |
vector short int arg_si, result_si, expected_si; |
| 27 |
|
| 28 |
vector bool int arg_bi, result_bi, expected_bi; |
| 29 |
vector unsigned int arg_ui, result_ui, expected_ui; |
| 30 |
vector int arg_int, result_int, expected_int; |
| 31 |
|
| 32 |
vector bool long long int arg_blli, result_blli, expected_blli; |
| 33 |
vector unsigned long long int arg_ulli, result_ulli, expected_ulli; |
| 34 |
vector long long int arg_lli, result_lli, expected_lli; |
| 35 |
|
| 36 |
vector __uint128_t arg_uint128, result_uint128, expected_uint128; |
| 37 |
vector __int128_t arg_int128, result_int128, expected_int128; |
| 38 |
|
| 39 |
vector float arg_f, result_f, expected_f; |
| 40 |
vector double arg_d, result_d, expected_d; |
| 41 |
|
| 42 |
/* 8-bit ints */ |
| 43 |
/* The element is a byte. Reversing the byte in each byte element |
| 44 |
gives the same value. */ |
| 45 |
arg_bc = (vector bool char) {0x01, 0x23, 0x45, 0x67, |
| 46 |
0x7E, 0x7C, 0x7A, 0x78, |
| 47 |
0x02, 0x46, 0x7A, 0x7E, |
| 48 |
0x13, 0x57, 0x7B, 0x7F}; |
| 49 |
expected_bc = arg_bc; |
| 50 |
|
| 51 |
result_bc = vec_revb (arg_bc); |
| 52 |
|
| 53 |
for (i = 0; i < 16; i++) { |
| 54 |
if (result_bc[i] != expected_bc[i]) |
| 55 |
#ifdef DEBUG |
| 56 |
printf("arg_bc[%d] = 0x%x, result_bc[%d] = 0x%x, expected_bc[%d] = 0x%x\n", |
| 57 |
i, arg_bc[i], i, result_bc[i], i, expected_bc[i]); |
| 58 |
#else |
| 59 |
abort(); |
| 60 |
#endif |
| 61 |
} |
| 62 |
|
| 63 |
arg_uc = (vector unsigned char) {0x01, 0x23, 0x45, 0x67, |
| 64 |
0x7E, 0x7C, 0x7A, 0x78, |
| 65 |
0x02, 0x46, 0x7A, 0x7E, |
| 66 |
0x13, 0x57, 0x7B, 0x7F}; |
| 67 |
expected_uc = arg_uc; |
| 68 |
|
| 69 |
result_uc = vec_revb (arg_uc); |
| 70 |
|
| 71 |
for (i = 0; i < 16; i++) { |
| 72 |
if (result_uc[i] != expected_uc[i]) |
| 73 |
#ifdef DEBUG |
| 74 |
printf("arg_uc[%d] = 0x%x, result_uc[%d] = 0x%x, expected_uc[%d] = 0x%x\n", |
| 75 |
i, arg_uc[i], i, result_uc[i], i, expected_uc[i]); |
| 76 |
#else |
| 77 |
abort(); |
| 78 |
#endif |
| 79 |
} |
| 80 |
|
| 81 |
arg_sc = (vector signed char) {0x01, 0x23, 0x45, 0x67, |
| 82 |
0x7E, 0x7C, 0x7A, 0x78, |
| 83 |
0x02, 0x46, 0x7A, 0x7E, |
| 84 |
0x13, 0x57, 0x7B, 0x7F}; |
| 85 |
expected_sc = arg_sc; |
| 86 |
|
| 87 |
result_sc = vec_revb (arg_sc); |
| 88 |
|
| 89 |
for (i = 0; i < 16; i++) { |
| 90 |
if (result_sc[i] != expected_sc[i]) |
| 91 |
#ifdef DEBUG |
| 92 |
printf("arg_sc[%d] = 0x%x, result_sc[%d] = 0x%x, expected_sc[%d] = 0x%x\n", |
| 93 |
i, arg_sc[i], i, result_sc[i], i, expected_sc[i]); |
| 94 |
#else |
| 95 |
abort(); |
| 96 |
#endif |
| 97 |
} |
| 98 |
|
| 99 |
/* 16-bit ints */ |
| 100 |
arg_bsi = (vector bool short int) {0x0123, 0x4567, 0xFEDC, 0xBA98, 0x0246, |
| 101 |
0x8ACE, 0x1357, 0x9BDF}; |
| 102 |
expected_bsi = (vector bool short int) {0x2301, 0x6745, 0xDCFE, 0x98BA, |
| 103 |
0x4602, 0xCE8A, 0x5713, 0xDF9B}; |
| 104 |
|
| 105 |
result_bsi = vec_revb (arg_bsi); |
| 106 |
|
| 107 |
for (i = 0; i < 8; i++) { |
| 108 |
if (result_bsi[i] != expected_bsi[i]) |
| 109 |
#ifdef DEBUG |
| 110 |
printf("arg_bsi[%d] = 0x%x, result_bsi[%d] = 0x%x, expected_bsi[%d] = 0x%x\n", |
| 111 |
i, arg_bsi[i], i, result_bsi[i], i, expected_bsi[i]); |
| 112 |
#else |
| 113 |
abort(); |
| 114 |
#endif |
| 115 |
} |
| 116 |
|
| 117 |
arg_usi = (vector unsigned short int) {0x0123, 0x4567, 0xFEDC, 0xBA98, |
| 118 |
0x0246, 0x8ACE, 0x1357, 0x9BDF}; |
| 119 |
expected_usi = (vector unsigned short int) {0x2301, 0x6745, 0xDCFE, 0x98BA, |
| 120 |
0x4602, 0xCE8A, 0x5713, 0xDF9B}; |
| 121 |
|
| 122 |
result_usi = vec_revb (arg_usi); |
| 123 |
|
| 124 |
for (i = 0; i < 8; i++) { |
| 125 |
if (result_usi[i] != expected_usi[i]) |
| 126 |
#ifdef DEBUG |
| 127 |
printf("arg_usi[%d] = 0x%x, result_usi[%d] = 0x%x, expected_usi[%d] = 0x%x\n", |
| 128 |
i, arg_usi[i], i, result_usi[i], i, expected_usi[i]); |
| 129 |
#else |
| 130 |
abort(); |
| 131 |
#endif |
| 132 |
} |
| 133 |
|
| 134 |
arg_si = (vector short int) {0x0123, 0x4567, 0xFEDC, 0xBA98, 0x0246, 0x8ACE, |
| 135 |
0x1357, 0x9BDF}; |
| 136 |
expected_si = (vector short int) {0x2301, 0x6745, 0xDCFE, 0x98BA, 0x4602, |
| 137 |
0xCE8A, 0x5713, 0xDF9B}; |
| 138 |
|
| 139 |
result_si = vec_revb (arg_si); |
| 140 |
|
| 141 |
for (i = 0; i < 8; i++) { |
| 142 |
if (result_si[i] != expected_si[i]) |
| 143 |
#ifdef DEBUG |
| 144 |
printf("arg_si[%d] = 0x%x, result_si[%d] = 0x%x, expected_si[%d] = 0x%x\n", |
| 145 |
i, arg_si[i], i, result_si[i], i, expected_si[i]); |
| 146 |
#else |
| 147 |
abort(); |
| 148 |
#endif |
| 149 |
} |
| 150 |
|
| 151 |
/* 32-bit ints */ |
| 152 |
arg_bi = (vector bool int) {0x01234567, 0xFEDCBA98, 0x02468ACE, 0x13579BDF}; |
| 153 |
expected_bi = (vector bool int) {0x67452301, 0x98BADCFE, 0xCE8A4602, |
| 154 |
0xDF9B5713}; |
| 155 |
|
| 156 |
result_bi = vec_revb (arg_bi); |
| 157 |
|
| 158 |
for (i = 0; i < 4; i++) { |
| 159 |
if (result_bi[i] != expected_bi[i]) |
| 160 |
#ifdef DEBUG |
| 161 |
printf("arg_bi[%d] = 0x%x, result_bi[%d] = 0x%x, expected_bi[%d] = 0x%x\n", |
| 162 |
i, arg_bi[i], i, result_bi[i], i, expected_bi[i]); |
| 163 |
#else |
| 164 |
abort(); |
| 165 |
#endif |
| 166 |
} |
| 167 |
|
| 168 |
arg_ui = (vector unsigned int) {0x01234567, 0xFEDCBA98, 0x02468ACE, |
| 169 |
0x13579BDF}; |
| 170 |
expected_ui = (vector unsigned int) {0x67452301, 0x98BADCFE, 0xCE8A4602, |
| 171 |
0xDF9B5713}; |
| 172 |
|
| 173 |
result_ui = vec_revb (arg_ui); |
| 174 |
|
| 175 |
for (i = 0; i < 4; i++) { |
| 176 |
if (result_ui[i] != expected_ui[i]) |
| 177 |
#ifdef DEBUG |
| 178 |
printf("arg_ui[%d] = 0x%x, result_ui[%d] = 0x%x, expected_ui[%d] = 0x%x\n", |
| 179 |
i, arg_ui[i], i, result_ui[i], i, expected_ui[i]); |
| 180 |
#else |
| 181 |
abort(); |
| 182 |
#endif |
| 183 |
} |
| 184 |
|
| 185 |
arg_int = (vector int) {0x01234567, 0xFEDCBA98, 0x02468ACE, 0x13579BDF}; |
| 186 |
expected_int = (vector int) {0x67452301, 0x98BADCFE, 0xCE8A4602, 0xDF9B5713}; |
| 187 |
|
| 188 |
result_int = vec_revb (arg_int); |
| 189 |
|
| 190 |
for (i = 0; i < 4; i++) { |
| 191 |
if (result_int[i] != expected_int[i]) |
| 192 |
#ifdef DEBUG |
| 193 |
printf("arg_int[%d] = 0x%x, result_int[%d] = 0x%x, expected_int[%d] = 0x%x\n", |
| 194 |
i, arg_int[i], i, result_int[i], i, expected_int[i]); |
| 195 |
#else |
| 196 |
abort(); |
| 197 |
#endif |
| 198 |
} |
| 199 |
|
| 200 |
/* 64-bit ints */ |
| 201 |
arg_blli = (vector bool long long int) {0x01234567FEDCBA98, |
| 202 |
0x02468ACE13579BDF}; |
| 203 |
expected_blli = (vector bool long long int) {0x98BADCFE67452301, |
| 204 |
0xDF9B5713CE8A4602}; |
| 205 |
|
| 206 |
result_blli = vec_revb (arg_blli); |
| 207 |
|
| 208 |
for (i = 0; i < 2; i++) { |
| 209 |
if (result_blli[i] != expected_blli[i]) |
| 210 |
#ifdef DEBUG |
| 211 |
printf("arg_blli[%d] = 0x%x, result_blli[%d] = 0x%llx, expected_blli[%d] = 0x%llx\n", |
| 212 |
i, arg_blli[i], i, result_blli[i], i, expected_blli[i]); |
| 213 |
#else |
| 214 |
abort(); |
| 215 |
#endif |
| 216 |
} |
| 217 |
|
| 218 |
arg_ulli = (vector unsigned long long int) {0x01234567FEDCBA98, |
| 219 |
0x02468ACE13579BDF}; |
| 220 |
expected_ulli = (vector unsigned long long int) {0x98BADCFE67452301, |
| 221 |
0xDF9B5713CE8A4602}; |
| 222 |
|
| 223 |
result_ulli = vec_revb (arg_ulli); |
| 224 |
|
| 225 |
for (i = 0; i < 2; i++) { |
| 226 |
if (result_ulli[i] != expected_ulli[i]) |
| 227 |
#ifdef DEBUG |
| 228 |
printf("arg_ulli[%d] = 0x%x, result_ulli[%d] = 0x%llx, expected_ulli[%d] = 0x%llx\n", |
| 229 |
i, arg_ulli[i], i, result_ulli[i], i, expected_ulli[i]); |
| 230 |
#else |
| 231 |
abort(); |
| 232 |
#endif |
| 233 |
} |
| 234 |
|
| 235 |
arg_lli = (vector long long int) {0x01234567FEDCBA98, 0x02468ACE13579BDF}; |
| 236 |
expected_lli = (vector long long int) {0x98BADCFE67452301, |
| 237 |
0xDF9B5713CE8A4602}; |
| 238 |
|
| 239 |
result_lli = vec_revb (arg_lli); |
| 240 |
|
| 241 |
for (i = 0; i < 2; i++) { |
| 242 |
if (result_lli[i] != expected_lli[i]) |
| 243 |
#ifdef DEBUG |
| 244 |
printf("arg_lli[%d] = 0x%x, result_lli[%d] = 0x%llx, expected_lli[%d] = 0x%llx\n", |
| 245 |
i, arg_lli[i], i, result_lli[i], i, expected_lli[i]); |
| 246 |
#else |
| 247 |
abort(); |
| 248 |
#endif |
| 249 |
} |
| 250 |
|
| 251 |
/* 128-bit ints */ |
| 252 |
arg_uint128[0] = 0x1627384950617243; |
| 253 |
arg_uint128[0] = arg_uint128[0] << 64; |
| 254 |
arg_uint128[0] |= 0x9405182930415263; |
| 255 |
expected_uint128[0] = 0x6352413029180594; |
| 256 |
expected_uint128[0] = expected_uint128[0] << 64; |
| 257 |
expected_uint128[0] |= 0x4372615049382716; |
| 258 |
|
| 259 |
result_uint128 = vec_revb (arg_uint128); |
| 260 |
|
| 261 |
if (result_uint128[0] != expected_uint128[0]) |
| 262 |
{ |
| 263 |
#ifdef DEBUG |
| 264 |
printf("result_uint128[0] doesn't match expected_u128[0]\n"); |
| 265 |
printf("arg_uint128[0] = %llx ", arg_uint128[0] >> 64); |
| 266 |
printf(" %llx\n", arg_uint128[0] & 0xFFFFFFFFFFFFFFFF); |
| 267 |
|
| 268 |
printf("result_uint128[0] = %llx ", result_uint128[0] >> 64); |
| 269 |
printf(" %llx\n", result_uint128[0] & 0xFFFFFFFFFFFFFFFF); |
| 270 |
|
| 271 |
printf("expected_uint128[0] = %llx ", expected_uint128[0] >> 64); |
| 272 |
printf(" %llx\n", expected_uint128[0] & 0xFFFFFFFFFFFFFFFF); |
| 273 |
#else |
| 274 |
abort(); |
| 275 |
#endif |
| 276 |
} |
| 277 |
|
| 278 |
arg_int128[0] = 0x1627384950617283; |
| 279 |
arg_int128[0] = arg_int128[0] << 64; |
| 280 |
arg_int128[0] |= 0x9405182930415263; |
| 281 |
expected_int128[0] = 0x6352413029180594; |
| 282 |
expected_int128[0] = expected_int128[0] << 64; |
| 283 |
expected_int128[0] |= 0x8372615049382716;; |
| 284 |
|
| 285 |
result_int128 = vec_revb (arg_int128); |
| 286 |
|
| 287 |
if (result_int128[0] != expected_int128[0]) |
| 288 |
{ |
| 289 |
#ifdef DEBUG |
| 290 |
printf("result_int128[0] doesn't match expected128[0]\n"); |
| 291 |
printf("arg_int128[0] = %llx ", arg_int128[0] >> 64); |
| 292 |
printf(" %llx\n", arg_int128[0] & 0xFFFFFFFFFFFFFFFF); |
| 293 |
|
| 294 |
printf("result_int128[0] = %llx ", result_int128[0] >> 64); |
| 295 |
printf(" %llx\n", result_int128[0] & 0xFFFFFFFFFFFFFFFF); |
| 296 |
|
| 297 |
printf("expected_int128[0] = %llx ", expected_int128[0] >> 64); |
| 298 |
printf(" %llx\n", expected_int128[0] & 0xFFFFFFFFFFFFFFFF); |
| 299 |
#else |
| 300 |
abort(); |
| 301 |
#endif |
| 302 |
} |
| 303 |
|
| 304 |
/* 32-bit floats */ |
| 305 |
/* 0x42f7224e, 0x43e471ec, 0x49712062, 0x4a0f2b38 */ |
| 306 |
arg_f = (vector float) {123.567, 456.89, 987654.123456, 2345678.0}; |
| 307 |
/* 0x4e22F742, 0xec71e443, 0x62207149, 0x382b0f4a */ |
| 308 |
expected_f = (vector float) {683528320.0, |
| 309 |
-1169716232068291395011477504.0, |
| 310 |
739910526898278498304.0, |
| 311 |
0.0000407838160754181444644927978515625}; |
| 312 |
|
| 313 |
result_f = vec_revb (arg_f); |
| 314 |
|
| 315 |
for (i = 0; i < 4; i++) { |
| 316 |
if (result_f[i] != expected_f[i]) |
| 317 |
#ifdef DEBUG |
| 318 |
printf(" arg_f[%d] = %f, result_f[%d] = %f, expected_f[%d] = %f\n", |
| 319 |
i, arg_f[i], i, result_f[i], i, expected_f[i]); |
| 320 |
#else |
| 321 |
abort(); |
| 322 |
#endif |
| 323 |
} |
| 324 |
|
| 325 |
/* 64-bit floats */ |
| 326 |
/* 0x419D6F34547E6B75 0x4194E5FEC781948B */ |
| 327 |
arg_d = (vector double) {123456789.123456789, 87654321.87654321}; |
| 328 |
/* 0x756B7E54346F9D41 0x8B9481C7FEE59441 */ |
| 329 |
expected_d = (vector double) {4.12815412905659550518671402044E257, |
| 330 |
-6.99269992046390236552018719554E-253}; |
| 331 |
|
| 332 |
result_d = vec_revb (arg_d); |
| 333 |
|
| 334 |
for (i = 0; i < 2; i++) { |
| 335 |
if (result_d[i] != expected_d[i]) |
| 336 |
#ifdef DEBUG |
| 337 |
printf("arg_d[%d] = %f, result_d[%d] = %f, expected_d[%d] = %f\n", |
| 338 |
i, arg_d[i], i, result_d[i], i, expected_d[i]); |
| 339 |
#else |
| 340 |
abort(); |
| 341 |
#endif |
| 342 |
} |
| 343 |
} |