| /* |
| |
| Copyright (c) 2009, 2010, 2011, 2012, 2013 STMicroelectronics |
| Written by Christophe Lyon |
| |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), to deal |
| in the Software without restriction, including without limitation the rights |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the Software is |
| furnished to do so, subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be included in |
| all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| THE SOFTWARE. |
| |
| */ |
| |
| #ifndef _STM_ARM_NEON_REF_H_ |
| #define _STM_ARM_NEON_REF_H_ |
| |
| #if defined(__cplusplus) |
| #include <cstdio> |
| #include <cinttypes> |
| #include <cstring> |
| #else |
| #include <stdio.h> |
| #if defined(_MSC_VER) |
| #include "msinttypes.h" |
| #include <float.h> /* for isnan() ... */ |
| static int32_t _ptrNan[]={0x7fc00000L}; |
| #define NAN (*(float*)_ptrNan) |
| static int32_t _ptrInf[]={0x7f800000L}; |
| #define INFINITY (*(float*)_ptrInf) |
| #define HUGE_VALF INFINITY |
| #else |
| #include <inttypes.h> |
| #endif |
| #include <string.h> |
| #endif |
| |
| #define xSTR(X) #X |
| #define STR(X) xSTR(X) |
| |
| #define xNAME1(V,T) V ## _ ## T |
| #define xNAME(V,T) xNAME1(V,T) |
| |
| #define VAR(V,T,W) xNAME(V,T##W) |
| #define VAR_DECL(V, T, W) T##W##_t VAR(V,T,W) |
| |
| #define VECT_NAME(T, W, N) T##W##x##N |
| #define VECT_ARRAY_NAME(T, W, N, L) T##W##x##N##x##L |
| #define VECT_TYPE(T, W, N) xNAME(VECT_NAME(T,W,N),t) |
| #define VECT_ARRAY_TYPE(T, W, N, L) xNAME(VECT_ARRAY_NAME(T,W,N,L),t) |
| |
| #define VECT_VAR(V,T,W,N) xNAME(V,VECT_NAME(T,W,N)) |
| #define VECT_VAR_DECL(V, T, W, N) T##W##_t VECT_VAR(V,T,W,N) |
| |
| /* This one is used for padding between input buffers. */ |
| #define PAD(V, T, W, N) char VECT_VAR(V,T,W,N)=42; |
| |
| /* Array declarations. */ |
| #define ARRAY(V, T, W, N) VECT_VAR_DECL(V,T,W,N)[N] |
| #define ARRAY4(V, T, W, N) VECT_VAR_DECL(V,T,W,N)[4] |
| |
| /* Arrays of vectors. */ |
| #define VECT_ARRAY_VAR(V,T,W,N,L) xNAME(V,VECT_ARRAY_NAME(T,W,N,L)) |
| #define VECT_ARRAY(V, T, W, N, L) T##W##_t VECT_ARRAY_VAR(V,T,W,N,L)[N*L] |
| |
| static int result_idx = 0; |
| #define DUMP(MSG,T,W,N,FMT) \ |
| fprintf(ref_file, "%s:%d:%s [] = { ", MSG, result_idx++, \ |
| STR(VECT_VAR(result, T, W, N))); \ |
| for(i=0; i<N ; i++) \ |
| { \ |
| fprintf(ref_file, "%" FMT ", ", VECT_VAR(result, T, W, N)[i]); \ |
| } \ |
| fprintf(ref_file, " }\n"); \ |
| DUMP4GCC(MSG,T,W,N,FMT); |
| |
| /* Use casts for remove sign bits */ |
| #define DUMP_POLY(MSG,T,W,N,FMT) \ |
| fprintf(ref_file, "%s:%d:%s [] = { ", MSG, result_idx++, \ |
| STR(VECT_VAR(result, T, W, N))); \ |
| for(i=0; i<N ; i++) \ |
| { \ |
| fprintf(ref_file, "%" FMT ", ", \ |
| (uint##W##_t)VECT_VAR(result, T, W, N)[i]); \ |
| } \ |
| fprintf(ref_file, " }\n"); \ |
| DUMP4GCC(MSG,T,W,N,FMT); |
| |
| #define DUMP_FP(MSG,T,W,N,FMT) \ |
| fprintf(ref_file, "%s:%d:%s [] = { ", MSG, result_idx++, \ |
| STR(VECT_VAR(result, T, W, N))); \ |
| for(i=0; i<N ; i++) \ |
| { \ |
| union fp_operand { \ |
| uint##W##_t i; \ |
| float##W##_t f; \ |
| } tmp; \ |
| tmp.f = VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(ref_file, "%" FMT ", ", tmp.i); \ |
| } \ |
| fprintf(ref_file, " }\n"); \ |
| DUMP4GCC_FP(MSG,T,W,N,FMT); |
| |
| #define DUMP4GCC(MSG,T,W,N,FMT) \ |
| fprintf(gcc_tests_file, "VECT_VAR_DECL(expected,%s,%d,%d) [] = { ", \ |
| STR(T), W, N); \ |
| for(i=0; i<(N-1) ; i++) \ |
| { \ |
| if (W < 32) { \ |
| uint32_t tmp = (uint##W##_t) VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(gcc_tests_file, "0x%" FMT ", ", tmp); \ |
| } else { \ |
| fprintf(gcc_tests_file, "0x%" FMT ", ", VECT_VAR(result, T, W, N)[i]); \ |
| } \ |
| } \ |
| if (W < 32) { \ |
| uint32_t tmp = (uint##W##_t) VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(gcc_tests_file, "0x%" FMT, tmp); \ |
| } else { \ |
| fprintf(gcc_tests_file, "0x%" FMT, VECT_VAR(result, T, W, N)[i]); \ |
| } \ |
| fprintf(gcc_tests_file, " };\n"); |
| |
| #define DUMP4GCC_FP(MSG,T,W,N,FMT) \ |
| { \ |
| union fp_operand { \ |
| uint##W##_t i; \ |
| float##W##_t f; \ |
| } tmp; \ |
| fprintf(gcc_tests_file, "VECT_VAR_DECL(expected,%s,%d,%d) [] = { ", \ |
| "hfloat", W, N); \ |
| for(i=0; i<(N-1) ; i++) \ |
| { \ |
| tmp.f = VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(gcc_tests_file, "0x%" FMT ", ", tmp.i); \ |
| } \ |
| tmp.f = VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(gcc_tests_file, "0x%" FMT, tmp.i); \ |
| fprintf(gcc_tests_file, " };\n"); \ |
| } |
| |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| #define float16_t __fp16 |
| |
| #define DUMP_FP16(MSG,T,W,N,FMT) \ |
| fprintf(ref_file, "%s:%d:%s [] = { ", MSG, result_idx++, \ |
| STR(VECT_VAR(result, T, W, N))); \ |
| for(i=0; i<N ; i++) \ |
| { \ |
| uint##W##_t tmp; \ |
| tmp = (uint##W##_t)VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(ref_file, "%" FMT ", ", tmp); \ |
| } \ |
| fprintf(ref_file, " }\n"); \ |
| DUMP4GCC_FP16(MSG,T,W,N,FMT); |
| |
| #define DUMP4GCC_FP16(MSG,T,W,N,FMT) \ |
| { \ |
| uint##W##_t tmp; \ |
| fprintf(gcc_tests_file, "VECT_VAR_DECL(expected,%s,%d,%d) [] = { ", \ |
| "hfloat", W, N); \ |
| for(i=0; i<(N-1) ; i++) \ |
| { \ |
| tmp = (uint##W##_t)VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(gcc_tests_file, "0x%" FMT ", ", tmp); \ |
| } \ |
| tmp = (uint##W##_t)VECT_VAR(result, T, W, N)[i]; \ |
| fprintf(gcc_tests_file, "0x%" FMT, tmp); \ |
| fprintf(gcc_tests_file, " };\n"); \ |
| } |
| #endif |
| |
| #define CLEAN_PATTERN_8 0x33 |
| #define CLEAN_PATTERN_16 0x3333 |
| #define CLEAN_PATTERN_32 0x33333333 |
| #define CLEAN_PATTERN_64 0x3333333333333333 |
| |
| #define CLEAN(VAR,T,W,N) \ |
| memset(VECT_VAR(VAR, T, W, N), \ |
| CLEAN_PATTERN_8, \ |
| sizeof(VECT_VAR(VAR, T, W, N))); |
| |
| #define CHECK_INIT(VAR,Q,T1,T2,W,N) \ |
| { \ |
| ARRAY(check_result, T1, W, N); \ |
| int i; \ |
| \ |
| vst1##Q##_##T2##W(VECT_VAR(check_result, T1, W, N), \ |
| VECT_VAR(VAR, T1, W, N)); \ |
| for(i=0; i<N ; i++) \ |
| { \ |
| /*if (VECT_VAR(check_result, T1, W, N)[i] == CLEAN_PATTERN_##W)*/ { \ |
| fprintf(stdout, "%s:%d: %s[%d] unintialized! %#x\n", \ |
| __FUNCTION__, __LINE__, \ |
| STR(VECT_VAR(VAR, T1, W, N)), i, \ |
| VECT_VAR(check_result, T1, W, N)[i]); \ |
| } \ |
| } \ |
| } |
| |
| /* Generic declarations: */ |
| extern FILE* log_file; |
| extern FILE* ref_file; |
| extern FILE* gcc_tests_file; |
| |
| /* Input buffers, one of each size */ |
| extern ARRAY(buffer, int, 8, 8); |
| extern ARRAY(buffer, int, 16, 4); |
| extern ARRAY(buffer, int, 32, 2); |
| extern ARRAY(buffer, int, 64, 1); |
| extern ARRAY(buffer, uint, 8, 8); |
| extern ARRAY(buffer, uint, 16, 4); |
| extern ARRAY(buffer, uint, 32, 2); |
| extern ARRAY(buffer, uint, 64, 1); |
| extern ARRAY(buffer, poly, 8, 8); |
| extern ARRAY(buffer, poly, 16, 4); |
| extern ARRAY(buffer, float, 32, 2); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern ARRAY(buffer, float, 16, 4); |
| #endif |
| extern ARRAY(buffer, int, 8, 16); |
| extern ARRAY(buffer, int, 16, 8); |
| extern ARRAY(buffer, int, 32, 4); |
| extern ARRAY(buffer, int, 64, 2); |
| extern ARRAY(buffer, uint, 8, 16); |
| extern ARRAY(buffer, uint, 16, 8); |
| extern ARRAY(buffer, uint, 32, 4); |
| extern ARRAY(buffer, uint, 64, 2); |
| extern ARRAY(buffer, poly, 8, 16); |
| extern ARRAY(buffer, poly, 16, 8); |
| extern ARRAY(buffer, float, 32, 4); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern ARRAY(buffer, float, 16, 8); |
| #endif |
| |
| /* The tests for vld1_dup and vdup expect at least 4 entries in the |
| input buffer, so force 1- and 2-elements initializers to have 4 |
| entries. */ |
| extern ARRAY(buffer_dup, int, 8, 8); |
| extern ARRAY(buffer_dup, int, 16, 4); |
| extern ARRAY4(buffer_dup, int, 32, 2); |
| extern ARRAY4(buffer_dup, int, 64, 1); |
| extern ARRAY(buffer_dup, uint, 8, 8); |
| extern ARRAY(buffer_dup, uint, 16, 4); |
| extern ARRAY4(buffer_dup, uint, 32, 2); |
| extern ARRAY4(buffer_dup, uint, 64, 1); |
| extern ARRAY(buffer_dup, poly, 8, 8); |
| extern ARRAY(buffer_dup, poly, 16, 4); |
| extern ARRAY4(buffer_dup, float, 32, 2); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern ARRAY4(buffer_dup, float, 16, 4); |
| #endif |
| extern ARRAY(buffer_dup, int, 8, 16); |
| extern ARRAY(buffer_dup, int, 16, 8); |
| extern ARRAY(buffer_dup, int, 32, 4); |
| extern ARRAY4(buffer_dup, int, 64, 2); |
| extern ARRAY(buffer_dup, uint, 8, 16); |
| extern ARRAY(buffer_dup, uint, 16, 8); |
| extern ARRAY(buffer_dup, uint, 32, 4); |
| extern ARRAY4(buffer_dup, uint, 64, 2); |
| extern ARRAY(buffer_dup, poly, 8, 16); |
| extern ARRAY(buffer_dup, poly, 16, 8); |
| extern ARRAY(buffer_dup, float, 32, 4); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern ARRAY(buffer_dup, float, 16, 8); |
| #endif |
| |
| /* Input buffers for vld2, one of each size */ |
| extern VECT_ARRAY(buffer_vld2, int, 8, 8, 2); |
| extern VECT_ARRAY(buffer_vld2, int, 16, 4, 2); |
| extern VECT_ARRAY(buffer_vld2, int, 32, 2, 2); |
| extern VECT_ARRAY(buffer_vld2, int, 64, 1, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 8, 8, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 16, 4, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 32, 2, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 64, 1, 2); |
| extern VECT_ARRAY(buffer_vld2, poly, 8, 8, 2); |
| extern VECT_ARRAY(buffer_vld2, poly, 16, 4, 2); |
| extern VECT_ARRAY(buffer_vld2, float, 32, 2, 2); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_ARRAY(buffer_vld2, float, 16, 4, 2); |
| #endif |
| extern VECT_ARRAY(buffer_vld2, int, 8, 16, 2); |
| extern VECT_ARRAY(buffer_vld2, int, 16, 8, 2); |
| extern VECT_ARRAY(buffer_vld2, int, 32, 4, 2); |
| extern VECT_ARRAY(buffer_vld2, int, 64, 2, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 8, 16, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 16, 8, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 32, 4, 2); |
| extern VECT_ARRAY(buffer_vld2, uint, 64, 2, 2); |
| extern VECT_ARRAY(buffer_vld2, poly, 8, 16, 2); |
| extern VECT_ARRAY(buffer_vld2, poly, 16, 8, 2); |
| extern VECT_ARRAY(buffer_vld2, float, 32, 4, 2); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_ARRAY(buffer_vld2, float, 16, 8, 2); |
| #endif |
| |
| /* Input buffers for vld3, one of each size */ |
| extern VECT_ARRAY(buffer_vld3, int, 8, 8, 3); |
| extern VECT_ARRAY(buffer_vld3, int, 16, 4, 3); |
| extern VECT_ARRAY(buffer_vld3, int, 32, 2, 3); |
| extern VECT_ARRAY(buffer_vld3, int, 64, 1, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 8, 8, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 16, 4, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 32, 2, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 64, 1, 3); |
| extern VECT_ARRAY(buffer_vld3, poly, 8, 8, 3); |
| extern VECT_ARRAY(buffer_vld3, poly, 16, 4, 3); |
| extern VECT_ARRAY(buffer_vld3, float, 32, 2, 3); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_ARRAY(buffer_vld3, float, 16, 4, 3); |
| #endif |
| extern VECT_ARRAY(buffer_vld3, int, 8, 16, 3); |
| extern VECT_ARRAY(buffer_vld3, int, 16, 8, 3); |
| extern VECT_ARRAY(buffer_vld3, int, 32, 4, 3); |
| extern VECT_ARRAY(buffer_vld3, int, 64, 2, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 8, 16, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 16, 8, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 32, 4, 3); |
| extern VECT_ARRAY(buffer_vld3, uint, 64, 2, 3); |
| extern VECT_ARRAY(buffer_vld3, poly, 8, 16, 3); |
| extern VECT_ARRAY(buffer_vld3, poly, 16, 8, 3); |
| extern VECT_ARRAY(buffer_vld3, float, 32, 4, 3); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_ARRAY(buffer_vld3, float, 16, 8, 3); |
| #endif |
| |
| /* Input buffers for vld4, one of each size */ |
| extern VECT_ARRAY(buffer_vld4, int, 8, 8, 4); |
| extern VECT_ARRAY(buffer_vld4, int, 16, 4, 4); |
| extern VECT_ARRAY(buffer_vld4, int, 32, 2, 4); |
| extern VECT_ARRAY(buffer_vld4, int, 64, 1, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 8, 8, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 16, 4, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 32, 2, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 64, 1, 4); |
| extern VECT_ARRAY(buffer_vld4, poly, 8, 8, 4); |
| extern VECT_ARRAY(buffer_vld4, poly, 16, 4, 4); |
| extern VECT_ARRAY(buffer_vld4, float, 32, 2, 4); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_ARRAY(buffer_vld4, float, 16, 4, 4); |
| #endif |
| extern VECT_ARRAY(buffer_vld4, int, 8, 16, 4); |
| extern VECT_ARRAY(buffer_vld4, int, 16, 8, 4); |
| extern VECT_ARRAY(buffer_vld4, int, 32, 4, 4); |
| extern VECT_ARRAY(buffer_vld4, int, 64, 2, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 8, 16, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 16, 8, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 32, 4, 4); |
| extern VECT_ARRAY(buffer_vld4, uint, 64, 2, 4); |
| extern VECT_ARRAY(buffer_vld4, poly, 8, 16, 4); |
| extern VECT_ARRAY(buffer_vld4, poly, 16, 8, 4); |
| extern VECT_ARRAY(buffer_vld4, float, 32, 4, 4); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_ARRAY(buffer_vld4, float, 16, 8, 4); |
| #endif |
| |
| /* Input buffers for vld2_lane */ |
| extern VECT_VAR_DECL(buffer_vld2_lane, int, 8, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, int, 16, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, int, 32, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, int, 64, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, uint, 8, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, uint, 16, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, uint, 32, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, uint, 64, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, poly, 8, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, poly, 16, 2)[2]; |
| extern VECT_VAR_DECL(buffer_vld2_lane, float, 32, 2)[2]; |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_VAR_DECL(buffer_vld2_lane, float, 16, 2)[2]; |
| #endif |
| |
| /* Input buffers for vld3_lane */ |
| extern VECT_VAR_DECL(buffer_vld3_lane, int, 8, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, int, 16, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, int, 32, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, int, 64, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, uint, 8, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, uint, 16, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, uint, 32, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, uint, 64, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, poly, 8, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, poly, 16, 3)[3]; |
| extern VECT_VAR_DECL(buffer_vld3_lane, float, 32, 3)[3]; |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_VAR_DECL(buffer_vld3_lane, float, 16, 3)[3]; |
| #endif |
| |
| /* Input buffers for vld4_lane */ |
| extern VECT_VAR_DECL(buffer_vld4_lane, int, 8, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, int, 16, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, int, 32, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, int, 64, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, uint, 8, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, uint, 16, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, uint, 32, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, uint, 64, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, poly, 8, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, poly, 16, 4)[4]; |
| extern VECT_VAR_DECL(buffer_vld4_lane, float, 32, 4)[4]; |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| extern VECT_VAR_DECL(buffer_vld4_lane, float, 16, 4)[4]; |
| #endif |
| |
| /* Output buffers, one of each size */ |
| static ARRAY(result, int, 8, 8); |
| static ARRAY(result, int, 16, 4); |
| static ARRAY(result, int, 32, 2); |
| static ARRAY(result, int, 64, 1); |
| static ARRAY(result, uint, 8, 8); |
| static ARRAY(result, uint, 16, 4); |
| static ARRAY(result, uint, 32, 2); |
| static ARRAY(result, uint, 64, 1); |
| static ARRAY(result, poly, 8, 8); |
| static ARRAY(result, poly, 16, 4); |
| static ARRAY(result, float, 32, 2); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| static ARRAY(result, float, 16, 4); |
| #endif |
| static ARRAY(result, int, 8, 16); |
| static ARRAY(result, int, 16, 8); |
| static ARRAY(result, int, 32, 4); |
| static ARRAY(result, int, 64, 2); |
| static ARRAY(result, uint, 8, 16); |
| static ARRAY(result, uint, 16, 8); |
| static ARRAY(result, uint, 32, 4); |
| static ARRAY(result, uint, 64, 2); |
| static ARRAY(result, poly, 8, 16); |
| static ARRAY(result, poly, 16, 8); |
| static ARRAY(result, float, 32, 4); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| static ARRAY(result, float, 16, 8); |
| #endif |
| |
| /* Dump results (generic function) */ |
| static void dump_results (char *test_name) |
| { |
| int i; |
| |
| fprintf(ref_file, "\n%s output:\n", test_name); |
| fprintf(gcc_tests_file, "\n%s output:\n", test_name); |
| |
| DUMP(test_name, int, 8, 8, PRId8); |
| DUMP(test_name, int, 16, 4, PRId16); |
| DUMP(test_name, int, 32, 2, PRId32); |
| DUMP(test_name, int, 64, 1, PRId64); |
| DUMP(test_name, uint, 8, 8, PRIu8); |
| DUMP(test_name, uint, 16, 4, PRIu16); |
| DUMP(test_name, uint, 32, 2, PRIu32); |
| DUMP(test_name, uint, 64, 1, PRIu64); |
| DUMP_POLY(test_name, poly, 8, 8, PRIu8); |
| DUMP_POLY(test_name, poly, 16, 4, PRIu16); |
| DUMP_FP(test_name, float, 32, 2, PRIx32); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| DUMP_FP16(test_name, float, 16, 4, PRIu16); |
| #endif |
| |
| DUMP(test_name, int, 8, 16, PRId8); |
| DUMP(test_name, int, 16, 8, PRId16); |
| DUMP(test_name, int, 32, 4, PRId32); |
| DUMP(test_name, int, 64, 2, PRId64); |
| DUMP(test_name, uint, 8, 16, PRIu8); |
| DUMP(test_name, uint, 16, 8, PRIu16); |
| DUMP(test_name, uint, 32, 4, PRIu32); |
| DUMP(test_name, uint, 64, 2, PRIu64); |
| DUMP_POLY(test_name, poly, 8, 16, PRIu8); |
| DUMP_POLY(test_name, poly, 16, 8, PRIu16); |
| DUMP_FP(test_name, float, 32, 4, PRIx32); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| DUMP_FP16(test_name, float, 16, 8, PRIu16); |
| #endif |
| } |
| |
| /* Dump results in hex (generic function) */ |
| static void dump_results_hex2 (const char *test_name, const char* comment) |
| { |
| int i; |
| |
| fprintf(ref_file, "\n%s%s output:\n", test_name, comment); |
| fprintf(gcc_tests_file, "\n%s%s output:\n", test_name, comment); |
| |
| DUMP(test_name, int, 8, 8, PRIx8); |
| DUMP(test_name, int, 16, 4, PRIx16); |
| DUMP(test_name, int, 32, 2, PRIx32); |
| DUMP(test_name, int, 64, 1, PRIx64); |
| DUMP(test_name, uint, 8, 8, PRIx8); |
| DUMP(test_name, uint, 16, 4, PRIx16); |
| DUMP(test_name, uint, 32, 2, PRIx32); |
| DUMP(test_name, uint, 64, 1, PRIx64); |
| DUMP_POLY(test_name, poly, 8, 8, PRIx8); |
| DUMP_POLY(test_name, poly, 16, 4, PRIx16); |
| DUMP_FP(test_name, float, 32, 2, PRIx32); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| DUMP_FP16(test_name, float, 16, 4, PRIx16); |
| #endif |
| |
| DUMP(test_name, int, 8, 16, PRIx8); |
| DUMP(test_name, int, 16, 8, PRIx16); |
| DUMP(test_name, int, 32, 4, PRIx32); |
| DUMP(test_name, int, 64, 2, PRIx64); |
| DUMP(test_name, uint, 8, 16, PRIx8); |
| DUMP(test_name, uint, 16, 8, PRIx16); |
| DUMP(test_name, uint, 32, 4, PRIx32); |
| DUMP(test_name, uint, 64, 2, PRIx64); |
| DUMP_POLY(test_name, poly, 8, 16, PRIx8); |
| DUMP_POLY(test_name, poly, 16, 8, PRIx16); |
| DUMP_FP(test_name, float, 32, 4, PRIx32); |
| #if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) ) |
| DUMP_FP16(test_name, float, 16, 8, PRIx16); |
| #endif |
| } |
| |
| static void dump_results_hex (const char *test_name) |
| { |
| dump_results_hex2(test_name, ""); |
| } |
| |
| #ifndef STM_ARM_NEON_MODELS |
| |
| /* This hack is to cope with various compilers/libc which may not |
| provide endian.h or cross-compilers such as llvm which includes the |
| host's endian.h. */ |
| #ifndef __arm__ |
| #include <endian.h> |
| #define THIS_ENDIAN __BYTE_ORDER |
| #else /* __arm__ */ |
| #ifdef __ARMEL__ |
| #define THIS_ENDIAN __LITTLE_ENDIAN |
| #else /* __ARMEL__ */ |
| #define THIS_ENDIAN __BIG_ENDIAN |
| #endif |
| #endif /* __arm__ */ |
| |
| #if THIS_ENDIAN == __LITTLE_ENDIAN |
| |
| typedef union { |
| struct { |
| int _xxx:27; |
| unsigned int QC:1; |
| int V:1; |
| int C:1; |
| int Z:1; |
| int N:1; |
| } b; |
| unsigned int word; |
| } _ARM_FPSCR; |
| |
| #else /* __BIG_ENDIAN */ |
| |
| typedef union { |
| struct { |
| int N:1; |
| int Z:1; |
| int C:1; |
| int V:1; |
| unsigned int QC:1; |
| int _dnm:27; |
| } b; |
| unsigned int word; |
| } _ARM_FPSCR; |
| |
| #endif /* __BIG_ENDIAN */ |
| |
| #ifdef __ARMCC_VERSION |
| register _ARM_FPSCR _afpscr_for_qc __asm("fpscr"); |
| # define Neon_Cumulative_Sat _afpscr_for_qc.b.QC |
| # define Set_Neon_Cumulative_Sat(x, depend) {Neon_Cumulative_Sat = (x);} |
| #else |
| /* GCC/ARM does not know this register */ |
| # define Neon_Cumulative_Sat __read_neon_cumulative_sat() |
| /* We need a fake dependency to ensure correct ordering of asm |
| statements to preset the QC flag value, and Neon operators writing |
| to QC. */ |
| #define Set_Neon_Cumulative_Sat(x, depend) \ |
| __set_neon_cumulative_sat((x), (depend)) |
| |
| # if defined(__aarch64__) |
| static volatile int __read_neon_cumulative_sat (void) { |
| _ARM_FPSCR _afpscr_for_qc; |
| asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc)); |
| return _afpscr_for_qc.b.QC; |
| } |
| |
| #define __set_neon_cumulative_sat(x, depend) { \ |
| _ARM_FPSCR _afpscr_for_qc; \ |
| asm volatile ("mrs %0,fpsr" : "=r" (_afpscr_for_qc)); \ |
| _afpscr_for_qc.b.QC = x; \ |
| asm volatile ("msr fpsr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \ |
| } |
| |
| # else |
| static volatile int __read_neon_cumulative_sat (void) { |
| _ARM_FPSCR _afpscr_for_qc; |
| asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc)); |
| return _afpscr_for_qc.b.QC; |
| } |
| |
| #define __set_neon_cumulative_sat(x, depend) { \ |
| _ARM_FPSCR _afpscr_for_qc; \ |
| asm volatile ("vmrs %0,fpscr" : "=r" (_afpscr_for_qc)); \ |
| _afpscr_for_qc.b.QC = x; \ |
| asm volatile ("vmsr fpscr,%1" : "=X" (depend) : "r" (_afpscr_for_qc)); \ |
| } |
| |
| # endif |
| #endif |
| |
| #endif /* STM_ARM_NEON_MODELS */ |
| |
| static void dump_neon_cumulative_sat(const char* msg, const char *name, |
| const char* t1, int w, int n) |
| { |
| fprintf(ref_file, "%s:%d:%s Neon cumulative saturation %d\n", msg, result_idx++, |
| name, Neon_Cumulative_Sat); |
| fprintf(gcc_tests_file, |
| "int VECT_VAR(expected_cumulative_sat,%s,%d,%d) = %d;\n", |
| t1, w, n, Neon_Cumulative_Sat); |
| } |
| |
| /* Clean output buffers before execution */ |
| static void clean_results (void) |
| { |
| result_idx = 0; |
| CLEAN(result, int, 8, 8); |
| CLEAN(result, int, 16, 4); |
| CLEAN(result, int, 32, 2); |
| CLEAN(result, int, 64, 1); |
| CLEAN(result, uint, 8, 8); |
| CLEAN(result, uint, 16, 4); |
| CLEAN(result, uint, 32, 2); |
| CLEAN(result, uint, 64, 1); |
| CLEAN(result, poly, 8, 8); |
| CLEAN(result, poly, 16, 4); |
| CLEAN(result, float, 32, 2); |
| |
| CLEAN(result, int, 8, 16); |
| CLEAN(result, int, 16, 8); |
| CLEAN(result, int, 32, 4); |
| CLEAN(result, int, 64, 2); |
| CLEAN(result, uint, 8, 16); |
| CLEAN(result, uint, 16, 8); |
| CLEAN(result, uint, 32, 4); |
| CLEAN(result, uint, 64, 2); |
| CLEAN(result, poly, 8, 16); |
| CLEAN(result, poly, 16, 8); |
| CLEAN(result, float, 32, 4); |
| } |
| |
| |
| /* Helpers to declare variables of various types */ |
| #define DECL_VARIABLE(VAR, T1, W, N) \ |
| volatile VECT_TYPE(T1, W, N) VECT_VAR(VAR, T1, W, N) |
| |
| #define DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR) \ |
| DECL_VARIABLE(VAR, int, 8, 8); \ |
| DECL_VARIABLE(VAR, int, 16, 4); \ |
| DECL_VARIABLE(VAR, int, 32, 2); \ |
| DECL_VARIABLE(VAR, int, 64, 1) |
| |
| #define DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR) \ |
| DECL_VARIABLE(VAR, uint, 8, 8); \ |
| DECL_VARIABLE(VAR, uint, 16, 4); \ |
| DECL_VARIABLE(VAR, uint, 32, 2); \ |
| DECL_VARIABLE(VAR, uint, 64, 1) |
| |
| #define DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR) \ |
| DECL_VARIABLE(VAR, int, 8, 16); \ |
| DECL_VARIABLE(VAR, int, 16, 8); \ |
| DECL_VARIABLE(VAR, int, 32, 4); \ |
| DECL_VARIABLE(VAR, int, 64, 2) |
| |
| #define DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR) \ |
| DECL_VARIABLE(VAR, uint, 8, 16); \ |
| DECL_VARIABLE(VAR, uint, 16, 8); \ |
| DECL_VARIABLE(VAR, uint, 32, 4); \ |
| DECL_VARIABLE(VAR, uint, 64, 2) |
| |
| #define DECL_VARIABLE_64BITS_VARIANTS(VAR) \ |
| DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \ |
| DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \ |
| DECL_VARIABLE(VAR, poly, 8, 8); \ |
| DECL_VARIABLE(VAR, poly, 16, 4); \ |
| DECL_VARIABLE(VAR, float, 32, 2) |
| |
| #define DECL_VARIABLE_128BITS_VARIANTS(VAR) \ |
| DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR); \ |
| DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR); \ |
| DECL_VARIABLE(VAR, poly, 8, 16); \ |
| DECL_VARIABLE(VAR, poly, 16, 8); \ |
| DECL_VARIABLE(VAR, float, 32, 4) |
| |
| #define DECL_VARIABLE_ALL_VARIANTS(VAR) \ |
| DECL_VARIABLE_64BITS_VARIANTS(VAR); \ |
| DECL_VARIABLE_128BITS_VARIANTS(VAR) |
| |
| #define DECL_VARIABLE_SIGNED_VARIANTS(VAR) \ |
| DECL_VARIABLE_64BITS_SIGNED_VARIANTS(VAR); \ |
| DECL_VARIABLE_128BITS_SIGNED_VARIANTS(VAR) |
| |
| #define DECL_VARIABLE_UNSIGNED_VARIANTS(VAR) \ |
| DECL_VARIABLE_64BITS_UNSIGNED_VARIANTS(VAR); \ |
| DECL_VARIABLE_128BITS_UNSIGNED_VARIANTS(VAR) |
| |
| /* Helpers to initialize vectors */ |
| #define VDUP(VAR, Q, T1, T2, W, N, V) \ |
| VECT_VAR(VAR, T1, W, N) = vdup##Q##_n_##T2##W(V) |
| |
| #define TEST_VSET_LANE(VAR, Q, T1, T2, W, N, L, V) \ |
| VECT_VAR(VAR, T1, W, N) = vset##Q##_lane_##T2##W(V, \ |
| VECT_VAR(VAR, T1, W, N), \ |
| L) |
| |
| /* We need to load initial values first, so rely on VLD1 */ |
| #define VLOAD(VAR, BUF, Q, T1, T2, W, N) \ |
| VECT_VAR(VAR, T1, W, N) = vld1##Q##_##T2##W(VECT_VAR(BUF, T1, W, N)) |
| |
| /* Helpers for macros with 1 constant and 5 variable arguments */ |
| #define TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR) \ |
| MACRO(VAR, , int, s, 8, 8); \ |
| MACRO(VAR, , int, s, 16, 4); \ |
| MACRO(VAR, , int, s, 32, 2); \ |
| MACRO(VAR, , int, s, 64, 1) |
| |
| #define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR) \ |
| MACRO(VAR, , uint, u, 8, 8); \ |
| MACRO(VAR, , uint, u, 16, 4); \ |
| MACRO(VAR, , uint, u, 32, 2); \ |
| MACRO(VAR, , uint, u, 64, 1) |
| |
| #define TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR) \ |
| MACRO(VAR, q, int, s, 8, 16); \ |
| MACRO(VAR, q, int, s, 16, 8); \ |
| MACRO(VAR, q, int, s, 32, 4); \ |
| MACRO(VAR, q, int, s, 64, 2) |
| |
| #define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO,VAR) \ |
| MACRO(VAR, q, uint, u, 8, 16); \ |
| MACRO(VAR, q, uint, u, 16, 8); \ |
| MACRO(VAR, q, uint, u, 32, 4); \ |
| MACRO(VAR, q, uint, u, 64, 2) |
| |
| #define TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR) \ |
| TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \ |
| TEST_MACRO_64BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR) |
| |
| #define TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR) \ |
| TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \ |
| TEST_MACRO_128BITS_UNSIGNED_VARIANTS_1_5(MACRO, VAR) |
| |
| #define TEST_MACRO_ALL_VARIANTS_1_5(MACRO, VAR) \ |
| TEST_MACRO_64BITS_VARIANTS_1_5(MACRO, VAR); \ |
| TEST_MACRO_128BITS_VARIANTS_1_5(MACRO, VAR) |
| |
| #define TEST_MACRO_SIGNED_VARIANTS_1_5(MACRO, VAR) \ |
| TEST_MACRO_64BITS_SIGNED_VARIANTS_1_5(MACRO, VAR); \ |
| TEST_MACRO_128BITS_SIGNED_VARIANTS_1_5(MACRO, VAR) |
| |
| /* Helpers for macros with 2 constant and 5 variable arguments */ |
| #define TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| MACRO(VAR1, VAR2, , int, s, 8, 8); \ |
| MACRO(VAR1, VAR2, , int, s, 16, 4); \ |
| MACRO(VAR1, VAR2, , int, s, 32, 2); \ |
| MACRO(VAR1, VAR2 , , int, s, 64, 1) |
| |
| #define TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| MACRO(VAR1, VAR2, , uint, u, 8, 8); \ |
| MACRO(VAR1, VAR2, , uint, u, 16, 4); \ |
| MACRO(VAR1, VAR2, , uint, u, 32, 2); \ |
| MACRO(VAR1, VAR2, , uint, u, 64, 1) |
| |
| #define TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| MACRO(VAR1, VAR2, q, int, s, 8, 16); \ |
| MACRO(VAR1, VAR2, q, int, s, 16, 8); \ |
| MACRO(VAR1, VAR2, q, int, s, 32, 4); \ |
| MACRO(VAR1, VAR2, q, int, s, 64, 2) |
| |
| #define TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| MACRO(VAR1, VAR2, q, uint, u, 8, 16); \ |
| MACRO(VAR1, VAR2, q, uint, u, 16, 8); \ |
| MACRO(VAR1, VAR2, q, uint, u, 32, 4); \ |
| MACRO(VAR1, VAR2, q, uint, u, 64, 2) |
| |
| #define TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \ |
| TEST_MACRO_64BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \ |
| MACRO(VAR1, VAR2, , poly, p, 8, 8); \ |
| MACRO(VAR1, VAR2, , poly, p, 16, 4) |
| |
| #define TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \ |
| TEST_MACRO_128BITS_UNSIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \ |
| MACRO(VAR1, VAR2, q, poly, p, 8, 16); \ |
| MACRO(VAR1, VAR2, q, poly, p, 16, 8) |
| |
| #define TEST_MACRO_ALL_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| TEST_MACRO_64BITS_VARIANTS_2_5(MACRO, VAR1, VAR2); \ |
| TEST_MACRO_128BITS_VARIANTS_2_5(MACRO, VAR1, VAR2) |
| |
| #define TEST_MACRO_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) \ |
| TEST_MACRO_64BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2); \ |
| TEST_MACRO_128BITS_SIGNED_VARIANTS_2_5(MACRO, VAR1, VAR2) |
| |
| #endif /* _STM_ARM_NEON_REF_H_ */ |
