gcc/testsuite/gcc.target/aarch64/vdup_n_1.c

/* Test vdup_lane intrinsics work correctly.  */
/* { dg-do run } */
/* { dg-options "-O1 --save-temps" } */

#include <arm_neon.h>

extern void abort (void);

float32x2_t __attribute__ ((noinline))
wrap_vdup_n_f32 (float32_t a)
{
  return vdup_n_f32 (a);
}

int __attribute__ ((noinline))
test_vdup_n_f32 ()
{
  float32_t a = 1.0;
  float32x2_t b;
  float32_t c[2];
  int i;

  b = wrap_vdup_n_f32 (a);
  vst1_f32 (c, b);
  for (i = 0; i < 2; i++)
    if (a != c[i])
      return 1;
  return 0;
}

float32x4_t __attribute__ ((noinline))
wrap_vdupq_n_f32 (float32_t a)
{
  return vdupq_n_f32 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_f32 ()
{
  float32_t a = 1.0;
  float32x4_t b;
  float32_t c[4];
  int i;

  b = wrap_vdupq_n_f32 (a);
  vst1q_f32 (c, b);
  for (i = 0; i < 4; i++)
    if (a != c[i])
      return 1;
  return 0;
}

float64x1_t __attribute__ ((noinline))
wrap_vdup_n_f64 (float64_t a)
{
  return vdup_n_f64 (a);
}

int __attribute__ ((noinline))
test_vdup_n_f64 ()
{
  float64_t a = 1.0;
  float64x1_t b;
  float64_t c[1];
  int i;

  b = wrap_vdup_n_f64 (a);
  vst1_f64 (c, b);
  for (i = 0; i < 1; i++)
    if (a != c[i])
      return 1;
  return 0;
}

float64x2_t __attribute__ ((noinline))
wrap_vdupq_n_f64 (float64_t a)
{
  return vdupq_n_f64 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_f64 ()
{
  float64_t a = 1.0;
  float64x2_t b;
  float64_t c[2];
  int i;

  b = wrap_vdupq_n_f64 (a);
  vst1q_f64 (c, b);
  for (i = 0; i < 2; i++)
    if (a != c[i])
      return 1;
  return 0;
}

poly8x8_t __attribute__ ((noinline))
wrap_vdup_n_p8 (poly8_t a)
{
  return vdup_n_p8 (a);
}

int __attribute__ ((noinline))
test_vdup_n_p8 ()
{
  poly8_t a = 1;
  poly8x8_t b;
  poly8_t c[8];
  int i;

  b = wrap_vdup_n_p8 (a);
  vst1_p8 (c, b);
  for (i = 0; i < 8; i++)
    if (a != c[i])
      return 1;
  return 0;
}

poly8x16_t __attribute__ ((noinline))
wrap_vdupq_n_p8 (poly8_t a)
{
  return vdupq_n_p8 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_p8 ()
{
  poly8_t a = 1;
  poly8x16_t b;
  poly8_t c[16];
  int i;

  b = wrap_vdupq_n_p8 (a);
  vst1q_p8 (c, b);
  for (i = 0; i < 16; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int8x8_t __attribute__ ((noinline))
wrap_vdup_n_s8 (int8_t a)
{
  return vdup_n_s8 (a);
}

int __attribute__ ((noinline))
test_vdup_n_s8 ()
{
  int8_t a = 1;
  int8x8_t b;
  int8_t c[8];
  int i;

  b = wrap_vdup_n_s8 (a);
  vst1_s8 (c, b);
  for (i = 0; i < 8; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int8x16_t __attribute__ ((noinline))
wrap_vdupq_n_s8 (int8_t a)
{
  return vdupq_n_s8 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_s8 ()
{
  int8_t a = 1;
  int8x16_t b;
  int8_t c[16];
  int i;

  b = wrap_vdupq_n_s8 (a);
  vst1q_s8 (c, b);
  for (i = 0; i < 16; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint8x8_t __attribute__ ((noinline))
wrap_vdup_n_u8 (uint8_t a)
{
  return vdup_n_u8 (a);
}

int __attribute__ ((noinline))
test_vdup_n_u8 ()
{
  uint8_t a = 1;
  uint8x8_t b;
  uint8_t c[8];
  int i;

  b = wrap_vdup_n_u8 (a);
  vst1_u8 (c, b);
  for (i = 0; i < 8; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint8x16_t __attribute__ ((noinline))
wrap_vdupq_n_u8 (uint8_t a)
{
  return vdupq_n_u8 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_u8 ()
{
  uint8_t a = 1;
  uint8x16_t b;
  uint8_t c[16];
  int i;

  b = wrap_vdupq_n_u8 (a);
  vst1q_u8 (c, b);
  for (i = 0; i < 16; i++)
    if (a != c[i])
      return 1;
  return 0;
}

poly16x4_t __attribute__ ((noinline))
wrap_vdup_n_p16 (poly16_t a)
{
  return vdup_n_p16 (a);
}

int __attribute__ ((noinline))
test_vdup_n_p16 ()
{
  poly16_t a = 1;
  poly16x4_t b;
  poly16_t c[4];
  int i;

  b = wrap_vdup_n_p16 (a);
  vst1_p16 (c, b);
  for (i = 0; i < 4; i++)
    if (a != c[i])
      return 1;
  return 0;
}

poly16x8_t __attribute__ ((noinline))
wrap_vdupq_n_p16 (poly16_t a)
{
  return vdupq_n_p16 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_p16 ()
{
  poly16_t a = 1;
  poly16x8_t b;
  poly16_t c[8];
  int i;

  b = wrap_vdupq_n_p16 (a);
  vst1q_p16 (c, b);
  for (i = 0; i < 8; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int16x4_t __attribute__ ((noinline))
wrap_vdup_n_s16 (int16_t a)
{
  return vdup_n_s16 (a);
}

int __attribute__ ((noinline))
test_vdup_n_s16 ()
{
  int16_t a = 1;
  int16x4_t b;
  int16_t c[4];
  int i;

  b = wrap_vdup_n_s16 (a);
  vst1_s16 (c, b);
  for (i = 0; i < 4; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int16x8_t __attribute__ ((noinline))
wrap_vdupq_n_s16 (int16_t a)
{
  return vdupq_n_s16 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_s16 ()
{
  int16_t a = 1;
  int16x8_t b;
  int16_t c[8];
  int i;

  b = wrap_vdupq_n_s16 (a);
  vst1q_s16 (c, b);
  for (i = 0; i < 8; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint16x4_t __attribute__ ((noinline))
wrap_vdup_n_u16 (uint16_t a)
{
  return vdup_n_u16 (a);
}

int __attribute__ ((noinline))
test_vdup_n_u16 ()
{
  uint16_t a = 1;
  uint16x4_t b;
  uint16_t c[4];
  int i;

  b = wrap_vdup_n_u16 (a);
  vst1_u16 (c, b);
  for (i = 0; i < 4; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint16x8_t __attribute__ ((noinline))
wrap_vdupq_n_u16 (uint16_t a)
{
  return vdupq_n_u16 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_u16 ()
{
  uint16_t a = 1;
  uint16x8_t b;
  uint16_t c[8];
  int i;

  b = wrap_vdupq_n_u16 (a);
  vst1q_u16 (c, b);
  for (i = 0; i < 8; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int32x2_t __attribute__ ((noinline))
wrap_vdup_n_s32 (int32_t a)
{
  return vdup_n_s32 (a);
}

int __attribute__ ((noinline))
test_vdup_n_s32 ()
{
  int32_t a = 1;
  int32x2_t b;
  int32_t c[2];
  int i;

  b = wrap_vdup_n_s32 (a);
  vst1_s32 (c, b);
  for (i = 0; i < 2; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int32x4_t __attribute__ ((noinline))
wrap_vdupq_n_s32 (int32_t a)
{
  return vdupq_n_s32 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_s32 ()
{
  int32_t a = 1;
  int32x4_t b;
  int32_t c[4];
  int i;

  b = wrap_vdupq_n_s32 (a);
  vst1q_s32 (c, b);
  for (i = 0; i < 4; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint32x2_t __attribute__ ((noinline))
wrap_vdup_n_u32 (uint32_t a)
{
  return vdup_n_u32 (a);
}

int __attribute__ ((noinline))
test_vdup_n_u32 ()
{
  uint32_t a = 1;
  uint32x2_t b;
  uint32_t c[2];
  int i;

  b = wrap_vdup_n_u32 (a);
  vst1_u32 (c, b);
  for (i = 0; i < 2; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint32x4_t __attribute__ ((noinline))
wrap_vdupq_n_u32 (uint32_t a)
{
  return vdupq_n_u32 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_u32 ()
{
  uint32_t a = 1;
  uint32x4_t b;
  uint32_t c[4];
  int i;

  b = wrap_vdupq_n_u32 (a);
  vst1q_u32 (c, b);
  for (i = 0; i < 4; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int64x1_t __attribute__ ((noinline))
wrap_vdup_n_s64 (int64_t a)
{
  return vdup_n_s64 (a);
}

int __attribute__ ((noinline))
test_vdup_n_s64 ()
{
  int64_t a = 1;
  int64x1_t b;
  int64_t c[1];
  int i;

  b = wrap_vdup_n_s64 (a);
  vst1_s64 (c, b);
  for (i = 0; i < 1; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int64x2_t __attribute__ ((noinline))
wrap_vdupq_n_s64 (int64_t a)
{
  return vdupq_n_s64 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_s64 ()
{
  int64_t a = 1;
  int64x2_t b;
  int64_t c[2];
  int i;

  b = wrap_vdupq_n_s64 (a);
  vst1q_s64 (c, b);
  for (i = 0; i < 2; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint64x1_t __attribute__ ((noinline))
wrap_vdup_n_u64 (uint64_t a)
{
  return vdup_n_u64 (a);
}

int __attribute__ ((noinline))
test_vdup_n_u64 ()
{
  uint64_t a = 1;
  uint64x1_t b;
  uint64_t c[1];
  int i;

  b = wrap_vdup_n_u64 (a);
  vst1_u64 (c, b);
  for (i = 0; i < 1; i++)
    if (a != c[i])
      return 1;
  return 0;
}

uint64x2_t __attribute__ ((noinline))
wrap_vdupq_n_u64 (uint64_t a)
{
  return vdupq_n_u64 (a);
}

int __attribute__ ((noinline))
test_vdupq_n_u64 ()
{
  uint64_t a = 1;
  uint64x2_t b;
  uint64_t c[2];
  int i;

  b = wrap_vdupq_n_u64 (a);
  vst1q_u64 (c, b);
  for (i = 0; i < 2; i++)
    if (a != c[i])
      return 1;
  return 0;
}

int
main ()
{
  if (test_vdup_n_f32 ())
    abort ();
  if (test_vdup_n_f64 ())
    abort ();
  if (test_vdup_n_p8 ())
    abort ();
  if (test_vdup_n_u8 ())
    abort ();
  if (test_vdup_n_s8 ())
    abort ();
  if (test_vdup_n_p16 ())
    abort ();
  if (test_vdup_n_s16 ())
    abort ();
  if (test_vdup_n_u16 ())
    abort ();
  if (test_vdup_n_s32 ())
    abort ();
  if (test_vdup_n_u32 ())
    abort ();
  if (test_vdup_n_s64 ())
    abort ();
  if (test_vdup_n_u64 ())
    abort ();
  if (test_vdupq_n_f32 ())
    abort ();
  if (test_vdupq_n_f64 ())
    abort ();
  if (test_vdupq_n_p8 ())
    abort ();
  if (test_vdupq_n_u8 ())
    abort ();
  if (test_vdupq_n_s8 ())
    abort ();
  if (test_vdupq_n_p16 ())
    abort ();
  if (test_vdupq_n_s16 ())
    abort ();
  if (test_vdupq_n_u16 ())
    abort ();
  if (test_vdupq_n_s32 ())
    abort ();
  if (test_vdupq_n_u32 ())
    abort ();
  if (test_vdupq_n_s64 ())
    abort ();
  if (test_vdupq_n_u64 ())
    abort ();
  return 0;
}

/* No asm checks for vdup_n_f32, vdupq_n_f32, vdup_n_f64 and vdupq_n_f64.
   Cannot force floating point value in general purpose regester.  */

/* Asm check for test_vdup_n_p8, test_vdup_n_s8, test_vdup_n_u8.  */
/* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.8b, w\[0-9\]+" 3 } } */

/* Asm check for test_vdupq_n_p8, test_vdupq_n_s8, test_vdupq_n_u8.  */
/* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.16b, w\[0-9\]+" 3 } } */

/* Asm check for test_vdup_n_p16, test_vdup_n_s16, test_vdup_n_u16.  */
/* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.4h, w\[0-9\]+" 3 } } */

/* Asm check for test_vdupq_n_p16, test_vdupq_n_s16, test_vdupq_n_u16.  */
/* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.8h, w\[0-9\]+" 3 } } */

/* Asm check for test_vdup_n_s32, test_vdup_n_u32.  */
/* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.2s, w\[0-9\]+" 2 } } */

/* Asm check for test_vdupq_n_s32, test_vdupq_n_u32.  */
/* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.4s, w\[0-9\]+" 2 } } */

/* Asm check for test_vdup_n_s64, test_vdup_n_u64 are left out.
   Attempts to make the compiler generate "dup\\td\[0-9\]+, x\[0-9\]+"
   are not practical.  */

/* Asm check for test_vdupq_n_s64, test_vdupq_n_u64.  */
/* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.2d, x\[0-9\]+" 2 } } */