/*

Copyright (c) 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.

*/

#if defined(__arm__) || defined(__aarch64__)
#include <arm_neon.h>
#else
#include "stm-arm-neon.h"
#endif
#include "stm-arm-neon-ref.h"

/* Initialization helpers; 4 slices are needed for vld2, vld3 and
   vld4.  */
#define MY_INIT_TAB(T,W,N) xNAME(INIT_TAB,N)(T##W##_t)
#define MY_INIT_TAB2(T,W,N) xNAME(INIT_TAB2,N)(T##W##_t)
#define MY_INIT_TAB3(T,W,N) xNAME(INIT_TAB3,N)(T##W##_t)
#define MY_INIT_TAB4(T,W,N) xNAME(INIT_TAB4,N)(T##W##_t)

/* Initialized input buffers.  */
#define VECT_VAR_DECL_INIT(V, T, W, N)			\
  VECT_VAR_DECL(V,T,W,N) [] = { MY_INIT_TAB(T,W,N) };

/* Specialized initializer with 4 entries, as used by vldX_dup and
   vdup tests, which iterate 4 times on input buffers.  */
#define VECT_VAR_DECL_INIT4(V, T, W, N)			\
  VECT_VAR_DECL(V,T,W,N) [] = { MY_INIT_TAB(T,W,4) };

/* Initializers for arrays of vectors.  */
#define VECT_ARRAY_INIT2(V, T, W, N)		\
  T##W##_t VECT_ARRAY_VAR(V,T,W,N,2)[] =	\
  { MY_INIT_TAB(T,W,N)				\
    MY_INIT_TAB2(T,W,N) };

#define VECT_ARRAY_INIT3(V, T, W, N)					\
  T##W##_t VECT_ARRAY_VAR(V,T,W,N,3)[] =				\
  { MY_INIT_TAB(T,W,N)							\
    MY_INIT_TAB2(T,W,N)							\
    MY_INIT_TAB3(T,W,N) };

#define VECT_ARRAY_INIT4(V, T, W, N)					\
  T##W##_t VECT_ARRAY_VAR(V,T,W,N,4)[] =				\
  { MY_INIT_TAB(T,W,N)							\
    MY_INIT_TAB2(T,W,N)							\
    MY_INIT_TAB3(T,W,N)							\
    MY_INIT_TAB4(T,W,N) };

/* Sample initialization vectors.  */
#define INIT_TAB_1(T)				\
  (T)-16,
#define INIT_TAB2_1(T)				\
  (T)-15,
#define INIT_TAB3_1(T)				\
  (T)-14,
#define INIT_TAB4_1(T)				\
  (T)-13,

#define INIT_TAB_2(T)				\
  (T)-16, (T)-15,
#define INIT_TAB2_2(T)				\
  (T)-14, (T)-13,
#define INIT_TAB3_2(T)				\
  (T)-12, (T)-11,
#define INIT_TAB4_2(T)				\
  (T)-10, (T)-9,

/* Initializer for vld3_lane tests.  */
#define INIT_TAB_3(T)				\
  (T)-16, (T)-15, (T)-14,

#define INIT_TAB_4(T)				\
  (T)-16, (T)-15, (T)-14, (T)-13,
#define INIT_TAB2_4(T)				\
  (T)-12, (T)-11, (T)-10, (T)-9,
#define INIT_TAB3_4(T)				\
  (T)-8, (T)-7, (T)-6, (T)-5,
#define INIT_TAB4_4(T)				\
  (T)-4, (T)-3, (T)-2, (T)-1,

#define INIT_TAB_8(T)							\
  (T)-16, (T)-15, (T)-14, (T)-13, (T)-12, (T)-11, (T)-10, (T)-9,
#define INIT_TAB2_8(T)							\
  (T)-8, (T)-7, (T)-6, (T)-5, (T)-4, (T)-3, (T)-2, (T)-1,
#define INIT_TAB3_8(T)							\
  (T)0, (T)1, (T)2, (T)3, (T)4, (T)5, (T)6, (T)7,
#define INIT_TAB4_8(T)							\
  (T)8, (T)9, (T)10, (T)11, (T)12, (T)13, (T)14, (T)15,

#define INIT_TAB_16(T)							\
  (T)-16, (T)-15, (T)-14, (T)-13, (T)-12, (T)-11, (T)-10, (T)-9,	\
  (T)-8, (T)-7, (T)-6, (T)-5, (T)-4, (T)-3, (T)-2, (T)-1,
#define INIT_TAB2_16(T)							\
  (T)0, (T)1, (T)2, (T)3, (T)4, (T)5, (T)6, (T)7,			\
  (T)8, (T)9, (T)10, (T)11, (T)12, (T)13, (T)14, (T)15,
#define INIT_TAB3_16(T)							\
  (T)16, (T)17, (T)18, (T)19, (T)20, (T)21, (T)22, (T)23,		\
   (T)24, (T)25, (T)26, (T)27, (T)28, (T)29, (T)30, (T)31,
#define INIT_TAB4_16(T)							\
  (T)32, (T)33, (T)34, (T)35, (T)36, (T)37, (T)38, (T)39,		\
  (T)40, (T)41, (T)42, (T)43, (T)44, (T)45, (T)46, (T)47,

/* Input buffers, one of each size.  */
/* Insert some padding to try to exhibit out of bounds accesses.  */
VECT_VAR_DECL_INIT(buffer, int, 8, 8);
PAD(buffer_pad, int, 8, 8);
VECT_VAR_DECL_INIT(buffer, int, 16, 4);
PAD(buffer_pad, int, 16, 4);
VECT_VAR_DECL_INIT(buffer, int, 32, 2);
PAD(buffer_pad, int, 32, 2);
VECT_VAR_DECL_INIT(buffer, int, 64, 1);
PAD(buffer_pad, int, 64, 1);
VECT_VAR_DECL_INIT(buffer, uint, 8, 8);
PAD(buffer_pad, uint, 8, 8);
VECT_VAR_DECL_INIT(buffer, poly, 8, 8);
PAD(buffer_pad, poly, 8, 8);
VECT_VAR_DECL_INIT(buffer, poly, 16, 4);
PAD(buffer_pad, poly, 16, 4);
VECT_VAR_DECL_INIT(buffer, uint, 16, 4);
PAD(buffer_pad, uint, 16, 4);
VECT_VAR_DECL_INIT(buffer, uint, 32, 2);
PAD(buffer_pad, uint, 32, 2);
VECT_VAR_DECL_INIT(buffer, uint, 64, 1);
PAD(buffer_pad, uint, 64, 1);
VECT_VAR_DECL_INIT(buffer, float, 32, 2);
PAD(buffer_pad, float, 32, 2);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
/* We need a different initialization for ARMCC, because the compiler
   performs the conversion to half-precision internal
   representation.  */
#ifdef __ARMCC_VERSION
__fp16 buffer_float16x4[4] = {-16, -15, -14, -13};
#else
VECT_VAR_DECL(buffer, float, 16, 4) [] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */};
#endif
PAD(buffer_pad, float, 16, 4);
#endif
VECT_VAR_DECL_INIT(buffer, int, 8, 16);
PAD(buffer_pad, int, 8, 16);
VECT_VAR_DECL_INIT(buffer, int, 16, 8);
PAD(buffer_pad, int, 16, 8);
VECT_VAR_DECL_INIT(buffer, int, 32, 4);
PAD(buffer_pad, int, 32, 4);
VECT_VAR_DECL_INIT(buffer, int, 64, 2);
PAD(buffer_pad, int, 64, 2);
VECT_VAR_DECL_INIT(buffer, uint, 8, 16);
PAD(buffer_pad, uint, 8, 16);
VECT_VAR_DECL_INIT(buffer, uint, 16, 8);
PAD(buffer_pad, uint, 16, 8);
VECT_VAR_DECL_INIT(buffer, uint, 32, 4);
PAD(buffer_pad, uint, 32, 4);
VECT_VAR_DECL_INIT(buffer, uint, 64, 2);
PAD(buffer_pad, uint, 64, 2);
VECT_VAR_DECL_INIT(buffer, poly, 8, 16);
PAD(buffer_pad, poly, 8, 16);
VECT_VAR_DECL_INIT(buffer, poly, 16, 8);
PAD(buffer_pad, poly, 16, 8);
VECT_VAR_DECL_INIT(buffer, float, 32, 4);
PAD(buffer_pad, float, 32, 4);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_float16x8[8] = {-16, -15, -14, -13, -12, -11, -10, -9};
#else
VECT_VAR_DECL(buffer, float, 16, 8) [] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */,
					  0xca00 /* -12 */, 0xc980 /* -11 */,
					  0xc900 /* -10 */, 0xc880 /* -9 */};
#endif
PAD(buffer_pad, 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.  */
VECT_VAR_DECL_INIT(buffer_dup, int, 8, 8);
VECT_VAR_DECL(buffer_dup_pad, int, 8, 8);
VECT_VAR_DECL_INIT(buffer_dup, int, 16, 4);
VECT_VAR_DECL(buffer_dup_pad, int, 16, 4);
VECT_VAR_DECL_INIT4(buffer_dup, int, 32, 2);
VECT_VAR_DECL(buffer_dup_pad, int, 32, 2);
VECT_VAR_DECL_INIT4(buffer_dup, int, 64, 1);
VECT_VAR_DECL(buffer_dup_pad, int, 64, 1);
VECT_VAR_DECL_INIT(buffer_dup, uint, 8, 8);
VECT_VAR_DECL(buffer_dup_pad, uint, 8, 8);
VECT_VAR_DECL_INIT(buffer_dup, uint, 16, 4);
VECT_VAR_DECL(buffer_dup_pad, uint, 16, 4);
VECT_VAR_DECL_INIT4(buffer_dup, uint, 32, 2);
VECT_VAR_DECL(buffer_dup_pad, uint, 32, 2);
VECT_VAR_DECL_INIT4(buffer_dup, uint, 64, 1);
VECT_VAR_DECL(buffer_dup_pad, uint, 64, 1);
VECT_VAR_DECL_INIT(buffer_dup, poly, 8, 8);
VECT_VAR_DECL(buffer_dup_pad, poly, 8, 8);
VECT_VAR_DECL_INIT(buffer_dup, poly, 16, 4);
VECT_VAR_DECL(buffer_dup_pad, poly, 16, 4);
VECT_VAR_DECL_INIT4(buffer_dup, float, 32, 2);
VECT_VAR_DECL(buffer_dup_pad, float, 32, 2);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_dup_float16x4[4] = {-16, -15, -14, -13};
#else
VECT_VAR_DECL(buffer_dup, float, 16, 4)[] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					     0xcb00 /* -14 */, 0xca80 /* -13 */};
#endif
PAD(buffer_dup_pad, float, 16, 4);
#endif
VECT_VAR_DECL_INIT(buffer_dup, int, 8, 16);
VECT_VAR_DECL(buffer_dup_pad, int, 8, 16);
VECT_VAR_DECL_INIT(buffer_dup, int, 16, 8);
VECT_VAR_DECL(buffer_dup_pad, int, 16, 8);
VECT_VAR_DECL_INIT(buffer_dup, int, 32, 4);
VECT_VAR_DECL(buffer_dup_pad, int, 32, 4);
VECT_VAR_DECL_INIT4(buffer_dup, int, 64, 2);
VECT_VAR_DECL(buffer_dup_pad, int, 64, 2);
VECT_VAR_DECL_INIT(buffer_dup, uint, 8, 16);
VECT_VAR_DECL(buffer_dup_pad, uint, 8, 16);
VECT_VAR_DECL_INIT(buffer_dup, uint, 16, 8);
VECT_VAR_DECL(buffer_dup_pad, uint, 16, 8);
VECT_VAR_DECL_INIT(buffer_dup, uint, 32, 4);
VECT_VAR_DECL(buffer_dup_pad, uint, 32, 4);
VECT_VAR_DECL_INIT4(buffer_dup, uint, 64, 2);
VECT_VAR_DECL(buffer_dup_pad, uint, 64, 2);
VECT_VAR_DECL_INIT(buffer_dup, poly, 8, 16);
VECT_VAR_DECL(buffer_dup_pad, poly, 8, 16);
VECT_VAR_DECL_INIT(buffer_dup, poly, 16, 8);
VECT_VAR_DECL(buffer_dup_pad, poly, 16, 8);
VECT_VAR_DECL_INIT(buffer_dup, float, 32, 4);
VECT_VAR_DECL(buffer_dup_pad, float, 32, 4);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_dup_float16x8[8] = {-16, -15, -14, -13, -12, -11, -10, -9};
#else
VECT_VAR_DECL(buffer_dup, float, 16, 8)[] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					     0xcb00 /* -14 */, 0xca80 /* -13 */,
					     0xca00 /* -12 */, 0xc980 /* -11 */,
					     0xc900 /* -10 */, 0xc880 /* -9 */};
#endif
PAD(buffer_dup_pad, float, 16, 8);
#endif

/* Input buffers for vld2, 1 of each size */
VECT_ARRAY_INIT2(buffer_vld2, int, 8, 8);
PAD(buffer_vld2_pad, int, 8, 8);
VECT_ARRAY_INIT2(buffer_vld2, int, 16, 4);
PAD(buffer_vld2_pad, int, 16, 4);
VECT_ARRAY_INIT2(buffer_vld2, int, 32, 2);
PAD(buffer_vld2_pad, int, 32, 2);
VECT_ARRAY_INIT2(buffer_vld2, int, 64, 1);
PAD(buffer_vld2_pad, int, 64, 1);
VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 8);
PAD(buffer_vld2_pad, uint, 8, 8);
VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 4);
PAD(buffer_vld2_pad, uint, 16, 4);
VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 2);
PAD(buffer_vld2_pad, uint, 32, 2);
VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 1);
PAD(buffer_vld2_pad, uint, 64, 1);
VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 8);
PAD(buffer_vld2_pad, poly, 8, 8);
VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 4);
PAD(buffer_vld2_pad, poly, 16, 4);
VECT_ARRAY_INIT2(buffer_vld2, float, 32, 2);
PAD(buffer_vld2_pad, float, 32, 2);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld2_float16x4x2[4*2] = {-16, -15, -14, -13, -12, -11, -10, -9};
#else
float16_t buffer_vld2_float16x4x2[4*2] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */,
					  0xca00 /* -12 */, 0xc980 /* -11 */,
					  0xc900 /* -10 */, 0xc880 /* -9 */};
#endif
PAD(buffer_vld2_pad, float, 16, 4);
#endif
VECT_ARRAY_INIT2(buffer_vld2, int, 8, 16);
PAD(buffer_vld2_pad, int, 8, 16);
VECT_ARRAY_INIT2(buffer_vld2, int, 16, 8);
PAD(buffer_vld2_pad, int, 16, 8);
VECT_ARRAY_INIT2(buffer_vld2, int, 32, 4);
PAD(buffer_vld2_pad, int, 32, 4);
VECT_ARRAY_INIT2(buffer_vld2, int, 64, 2);
PAD(buffer_vld2_pad, int, 64, 2);
VECT_ARRAY_INIT2(buffer_vld2, uint, 8, 16);
PAD(buffer_vld2_pad, uint, 8, 16);
VECT_ARRAY_INIT2(buffer_vld2, uint, 16, 8);
PAD(buffer_vld2_pad, uint, 16, 8);
VECT_ARRAY_INIT2(buffer_vld2, uint, 32, 4);
PAD(buffer_vld2_pad, uint, 32, 4);
VECT_ARRAY_INIT2(buffer_vld2, uint, 64, 2);
PAD(buffer_vld2_pad, uint, 64, 2);
VECT_ARRAY_INIT2(buffer_vld2, poly, 8, 16);
PAD(buffer_vld2_pad, poly, 8, 16);
VECT_ARRAY_INIT2(buffer_vld2, poly, 16, 8);
PAD(buffer_vld2_pad, poly, 16, 8);
VECT_ARRAY_INIT2(buffer_vld2, float, 32, 4);
PAD(buffer_vld2_pad, float, 32, 4);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld2_float16x8x2[8*2] = {-16, -15, -14, -13, -12, -11, -10, -9,
				       -8, -7, -6, -5, -4, -3, -2, -1};
#else
float16_t buffer_vld2_float16x8x2[8*2] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */,
					  0xca00 /* -12 */, 0xc980 /* -11 */,
					  0xc900 /* -10 */, 0xc880 /* -9 */,
					  0xc800 /* -8 */, 0xc700 /* -7 */,
					  0xc600 /* -6 */, 0xc500 /* -5 */,
					  0xc400 /* -4 */, 0xc200 /* -3 */,
					  0xc000 /* -2 */, 0xbc00 /* -1 */};
#endif
PAD(buffer_vld2_pad, float, 16, 8);
#endif

/* Input buffers for vld3, 1 of each size */
VECT_ARRAY_INIT3(buffer_vld3, int, 8, 8);
PAD(buffer_vld3_pad, int, 8, 8);
VECT_ARRAY_INIT3(buffer_vld3, int, 16, 4);
PAD(buffer_vld3_pad, int, 16, 4);
VECT_ARRAY_INIT3(buffer_vld3, int, 32, 2);
PAD(buffer_vld3_pad, int, 32, 2);
VECT_ARRAY_INIT3(buffer_vld3, int, 64, 1);
PAD(buffer_vld3_pad, int, 64, 1);
VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 8);
PAD(buffer_vld3_pad, uint, 8, 8);
VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 4);
PAD(buffer_vld3_pad, uint, 16, 4);
VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 2);
PAD(buffer_vld3_pad, uint, 32, 2);
VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 1);
PAD(buffer_vld3_pad, uint, 64, 1);
VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 8);
PAD(buffer_vld3_pad, poly, 8, 8);
VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 4);
PAD(buffer_vld3_pad, poly, 16, 4);
VECT_ARRAY_INIT3(buffer_vld3, float, 32, 2);
PAD(buffer_vld3_pad, float, 32, 2);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld3_float16x4x3[4*3] = {-16, -15, -14, -13, -12, -11, -10, -9,
				       -8, -7, -6, -5};
#else
float16_t buffer_vld3_float16x4x3[4*3] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */,
					  0xca00 /* -12 */, 0xc980 /* -11 */,
					  0xc900 /* -10 */, 0xc880 /* -9 */,
					  0xc800 /* -8 */, 0xc700 /* -7 */,
					  0xc600 /* -6 */, 0xc500 /* -5 */};
#endif
PAD(buffer_vld3_pad, float, 16, 4);
#endif
VECT_ARRAY_INIT3(buffer_vld3, int, 8, 16);
PAD(buffer_vld3_pad, int, 8, 16);
VECT_ARRAY_INIT3(buffer_vld3, int, 16, 8);
PAD(buffer_vld3_pad, int, 16, 8);
VECT_ARRAY_INIT3(buffer_vld3, int, 32, 4);
PAD(buffer_vld3_pad, int, 32, 4);
VECT_ARRAY_INIT3(buffer_vld3, int, 64, 2);
PAD(buffer_vld3_pad, int, 64, 2);
VECT_ARRAY_INIT3(buffer_vld3, uint, 8, 16);
PAD(buffer_vld3_pad, uint, 8, 16);
VECT_ARRAY_INIT3(buffer_vld3, uint, 16, 8);
PAD(buffer_vld3_pad, uint, 16, 8);
VECT_ARRAY_INIT3(buffer_vld3, uint, 32, 4);
PAD(buffer_vld3_pad, uint, 32, 4);
VECT_ARRAY_INIT3(buffer_vld3, uint, 64, 2);
PAD(buffer_vld3_pad, uint, 64, 2);
VECT_ARRAY_INIT3(buffer_vld3, poly, 8, 16);
PAD(buffer_vld3_pad, poly, 8, 16);
VECT_ARRAY_INIT3(buffer_vld3, poly, 16, 8);
PAD(buffer_vld3_pad, poly, 16, 8);
VECT_ARRAY_INIT3(buffer_vld3, float, 32, 4);
PAD(buffer_vld3_pad, float, 32, 4);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld3_float16x8x3[8*3] = {-16, -15, -14, -13, -12, -11, -10, -9,
				       -8, -7, -6, -5, -4, -3, -2, -1,
				       0, 1, 2, 3, 4, 5, 6, 7};
#else
float16_t buffer_vld3_float16x8x3[8*3] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */,
					  0xca00 /* -12 */, 0xc980 /* -11 */,
					  0xc900 /* -10 */, 0xc880 /* -9 */,
					  0xc800 /* -8 */, 0xc700 /* -7 */,
					  0xc600 /* -6 */, 0xc500 /* -6 */,
					  0xc400 /* -4 */, 0xc200 /* -3 */,
					  0xc000 /* -2 */, 0xbc00 /* -1 */,
					  0, 0x3c00 /* 1 */,
					  0x4000 /* 2 */, 0x4200 /* 3 */,
					  0x4400 /* 4 */, 0x4500 /* 5 */,
					  0x4600 /* 6 */, 0x4700 /* 7 */};
#endif
PAD(buffer_vld3_pad, float, 16, 8);
#endif

/* Input buffers for vld4, 1 of each size */
VECT_ARRAY_INIT4(buffer_vld4, int, 8, 8);
PAD(buffer_vld4_pad, int, 8, 8);
VECT_ARRAY_INIT4(buffer_vld4, int, 16, 4);
PAD(buffer_vld4_pad, int, 16, 4);
VECT_ARRAY_INIT4(buffer_vld4, int, 32, 2);
PAD(buffer_vld4_pad, int, 32, 2);
VECT_ARRAY_INIT4(buffer_vld4, int, 64, 1);
PAD(buffer_vld4_pad, int, 64, 1);
VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 8);
PAD(buffer_vld4_pad, uint, 8, 8);
VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 4);
PAD(buffer_vld4_pad, uint, 16, 4);
VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 2);
PAD(buffer_vld4_pad, uint, 32, 2);
VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 1);
PAD(buffer_vld4_pad, uint, 64, 1);
VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 8);
PAD(buffer_vld4_pad, poly, 8, 8);
VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 4);
PAD(buffer_vld4_pad, poly, 16, 4);
VECT_ARRAY_INIT4(buffer_vld4, float, 32, 2);
PAD(buffer_vld4_pad, float, 32, 2);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld4_float16x4x4[4*4] = {-16, -15, -14, -13, -12, -11, -10, -9,
				       -8, -7, -6, -5, -4, -3, -2, -1};
#else
float16_t buffer_vld4_float16x4x4[4*4] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */,
					  0xca00 /* -12 */, 0xc980 /* -11 */,
					  0xc900 /* -10 */, 0xc880 /* -9 */,
					  0xc800 /* -8 */, 0xc700 /* -7 */,
					  0xc600 /* -6 */, 0xc500 /* -5 */,
					  0xc400 /* -4 */, 0xc200 /* -3 */,
					  0xc000 /* -2 */, 0xbc00 /* -1 */};
#endif
PAD(buffer_vld4_pad, float, 16, 4);
#endif
VECT_ARRAY_INIT4(buffer_vld4, int, 8, 16);
PAD(buffer_vld4_pad, int, 8, 16);
VECT_ARRAY_INIT4(buffer_vld4, int, 16, 8);
PAD(buffer_vld4_pad, int, 16, 8);
VECT_ARRAY_INIT4(buffer_vld4, int, 32, 4);
PAD(buffer_vld4_pad, int, 32, 4);
VECT_ARRAY_INIT4(buffer_vld4, int, 64, 2);
PAD(buffer_vld4_pad, int, 64, 2);
VECT_ARRAY_INIT4(buffer_vld4, uint, 8, 16);
PAD(buffer_vld4_pad, uint, 8, 16);
VECT_ARRAY_INIT4(buffer_vld4, uint, 16, 8);
PAD(buffer_vld4_pad, uint, 16, 8);
VECT_ARRAY_INIT4(buffer_vld4, uint, 32, 4);
PAD(buffer_vld4_pad, uint, 32, 4);
VECT_ARRAY_INIT4(buffer_vld4, uint, 64, 2);
PAD(buffer_vld4_pad, uint, 64, 2);
VECT_ARRAY_INIT4(buffer_vld4, poly, 8, 16);
PAD(buffer_vld4_pad, poly, 8, 16);
VECT_ARRAY_INIT4(buffer_vld4, poly, 16, 8);
PAD(buffer_vld4_pad, poly, 16, 8);
VECT_ARRAY_INIT4(buffer_vld4, float, 32, 4);
PAD(buffer_vld4_pad, float, 32, 4);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld4_float16x8x4[8*4] = {-16, -15, -14, -13, -12, -11, -10, -9,
				       -8, -7, -6, -5, -4, -3, -2, -1,
				       0, 1, 2, 3, 4, 5, 6, 7,
				       8, 9, 10, 11, 12, 13, 14, 15};
#else
float16_t buffer_vld4_float16x8x4[8*4] = {0xcc00 /* -16 */, 0xcb80 /* -15 */,
					  0xcb00 /* -14 */, 0xca80 /* -13 */,
					  0xca00 /* -12 */, 0xc980 /* -11 */,
					  0xc900 /* -10 */, 0xc880 /* -9 */,
					  0xc800 /* -8 */, 0xc700 /* -7 */,
					  0xc600 /* -6 */, 0xc500 /* -6 */,
					  0xc400 /* -4 */, 0xc200 /* -3 */,
					  0xc000 /* -2 */, 0xbc00 /* -1 */,
					  0, 0x3c00 /* 1 */,
					  0x4000 /* 2 */, 0x4200 /* 3 */,
					  0x4400 /* 4 */, 0x4500 /* 5 */,
					  0x4600 /* 6 */, 0x4700 /* 7 */,
					  0x4800 /* 8 */, 0x4880 /* 9 */,
					  0x4900 /* 10 */, 0x4980 /* 11 */,
					  0x4a00 /* 12 */, 0x4a80 /* 13 */,
					  0x4b00 /* 14 */, 0x04b80 /* 15 */};
#endif
PAD(buffer_vld4_pad, float, 16, 8);
#endif

/* Input buffers for vld2_lane */
VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 8, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 16, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 32, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, int, 64, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 8, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 16, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 32, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, uint, 64, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, poly, 8, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, poly, 16, 2);
VECT_VAR_DECL_INIT(buffer_vld2_lane, float, 32, 2);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld2_lane_float16x2[2] = {-16, -15};
#else
VECT_VAR_DECL(buffer_vld2_lane, float, 16, 2) [] = {0xcc00 /* -16 */,
						    0xcb80 /* -15 */};
#endif
#endif

/* Input buffers for vld3_lane */
VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 8, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 16, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 32, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, int, 64, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 8, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 16, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 32, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, uint, 64, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, poly, 8, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, poly, 16, 3);
VECT_VAR_DECL_INIT(buffer_vld3_lane, float, 32, 3);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld3_lane_float16x3[3] = {-16, -15, -14};
#else
VECT_VAR_DECL(buffer_vld3_lane, float, 16, 3) [] = {0xcc00 /* -16 */,
						    0xcb80 /* -15 */,
						    0xcb00 /* -14 */};
#endif
#endif

/* Input buffers for vld4_lane */
VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 8, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 16, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 32, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, int, 64, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 8, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 16, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 32, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, uint, 64, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, poly, 8, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, poly, 16, 4);
VECT_VAR_DECL_INIT(buffer_vld4_lane, float, 32, 4);
#if defined(__ARM_FP16_FORMAT_IEEE) && ( ((__ARM_FP & 0x2) != 0) || ((__ARM_NEON_FP16_INTRINSICS & 1) != 0) )
#ifdef __ARMCC_VERSION
__fp16 buffer_vld4_lane_float16x4[4] = {-16, -15, -14, -13};
#else
VECT_VAR_DECL(buffer_vld4_lane, float, 16, 4) [] = {0xcc00 /* -16 */,
						    0xcb80 /* -15 */,
						    0xcb00 /* -14 */,
						    0xca80 /* -13 */};
#endif
#endif