diff options
Diffstat (limited to 'gcc-4.8/gcc/testsuite/gcc.target')
163 files changed, 8528 insertions, 231 deletions
diff --git a/gcc-4.8/gcc/testsuite/gcc.target/aarch64/scalar_intrinsics.c b/gcc-4.8/gcc/testsuite/gcc.target/aarch64/scalar_intrinsics.c index 1b8530843..cad70ab62 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/aarch64/scalar_intrinsics.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/aarch64/scalar_intrinsics.c @@ -1,7 +1,13 @@ /* { dg-do compile } */ /* { dg-options "-O2" } */ -#include "../../../config/aarch64/arm_neon.h" +#include <arm_neon.h> + +/* Used to force a variable to a SIMD register. */ +#define force_simd(V1) asm volatile ("mov %d0, %1.d[0]" \ + : "=w"(V1) \ + : "w"(V1) \ + : /* No clobbers */); /* { dg-final { scan-assembler-times "\\tadd\\tx\[0-9\]+" 2 } } */ @@ -31,7 +37,12 @@ test_vaddd_s64_2 (int64x1_t a, int64x1_t b, int64x1_t c, int64x1_t d) uint64x1_t test_vceqd_s64 (int64x1_t a, int64x1_t b) { - return vceqd_s64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vceqd_s64 (a, b); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tcmeq\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */ @@ -39,7 +50,11 @@ test_vceqd_s64 (int64x1_t a, int64x1_t b) uint64x1_t test_vceqzd_s64 (int64x1_t a) { - return vceqzd_s64 (a); + uint64x1_t res; + force_simd (a); + res = vceqzd_s64 (a); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tcmge\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 2 } } */ @@ -47,21 +62,36 @@ test_vceqzd_s64 (int64x1_t a) uint64x1_t test_vcged_s64 (int64x1_t a, int64x1_t b) { - return vcged_s64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vcged_s64 (a, b); + force_simd (res); + return res; } uint64x1_t test_vcled_s64 (int64x1_t a, int64x1_t b) { - return vcled_s64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vcled_s64 (a, b); + force_simd (res); + return res; } -/* { dg-final { scan-assembler-times "\\tcmge\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */ +/* Idiom recognition will cause this testcase not to generate + the expected cmge instruction, so do not check for it. */ uint64x1_t test_vcgezd_s64 (int64x1_t a) { - return vcgezd_s64 (a); + uint64x1_t res; + force_simd (a); + res = vcgezd_s64 (a); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tcmhs\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 1 } } */ @@ -69,7 +99,12 @@ test_vcgezd_s64 (int64x1_t a) uint64x1_t test_vcged_u64 (uint64x1_t a, uint64x1_t b) { - return vcged_u64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vcged_u64 (a, b); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tcmgt\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 2 } } */ @@ -77,13 +112,23 @@ test_vcged_u64 (uint64x1_t a, uint64x1_t b) uint64x1_t test_vcgtd_s64 (int64x1_t a, int64x1_t b) { - return vcgtd_s64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vcgtd_s64 (a, b); + force_simd (res); + return res; } uint64x1_t test_vcltd_s64 (int64x1_t a, int64x1_t b) { - return vcltd_s64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vcltd_s64 (a, b); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tcmgt\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */ @@ -91,7 +136,11 @@ test_vcltd_s64 (int64x1_t a, int64x1_t b) uint64x1_t test_vcgtzd_s64 (int64x1_t a) { - return vcgtzd_s64 (a); + uint64x1_t res; + force_simd (a); + res = vcgtzd_s64 (a); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tcmhi\\td\[0-9\]+, d\[0-9\]+, d\[0-9\]+" 1 } } */ @@ -99,7 +148,12 @@ test_vcgtzd_s64 (int64x1_t a) uint64x1_t test_vcgtd_u64 (uint64x1_t a, uint64x1_t b) { - return vcgtd_u64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vcgtd_u64 (a, b); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tcmle\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */ @@ -107,15 +161,24 @@ test_vcgtd_u64 (uint64x1_t a, uint64x1_t b) uint64x1_t test_vclezd_s64 (int64x1_t a) { - return vclezd_s64 (a); + uint64x1_t res; + force_simd (a); + res = vclezd_s64 (a); + force_simd (res); + return res; } -/* { dg-final { scan-assembler-times "\\tcmlt\\td\[0-9\]+, d\[0-9\]+, #?0" 1 } } */ +/* Idiom recognition will cause this testcase not to generate + the expected cmlt instruction, so do not check for it. */ uint64x1_t test_vcltzd_s64 (int64x1_t a) { - return vcltzd_s64 (a); + uint64x1_t res; + force_simd (a); + res = vcltzd_s64 (a); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\tdup\\tb\[0-9\]+, v\[0-9\]+\.b" 2 } } */ @@ -179,13 +242,23 @@ test_vdupd_lane_u64 (uint64x2_t a) int64x1_t test_vtst_s64 (int64x1_t a, int64x1_t b) { - return vtstd_s64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vtstd_s64 (a, b); + force_simd (res); + return res; } uint64x1_t test_vtst_u64 (uint64x1_t a, uint64x1_t b) { - return vtstd_u64 (a, b); + uint64x1_t res; + force_simd (a); + force_simd (b); + res = vtstd_s64 (a, b); + force_simd (res); + return res; } /* { dg-final { scan-assembler-times "\\taddp\\td\[0-9\]+, v\[0-9\]+\.2d" 1 } } */ @@ -722,7 +795,10 @@ test_vrshld_u64 (uint64x1_t a, uint64x1_t b) return vrshld_u64 (a, b); } -/* { dg-final { scan-assembler-times "\\tasr\\tx\[0-9\]+" 1 } } */ +/* Other intrinsics can generate an asr instruction (vcltzd, vcgezd), + so we cannot check scan-assembler-times. */ + +/* { dg-final { scan-assembler "\\tasr\\tx\[0-9\]+" } } */ int64x1_t test_vshrd_n_s64 (int64x1_t a) diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/neon/vst1Q_laneu64-1.c b/gcc-4.8/gcc/testsuite/gcc.target/arm/neon/vst1Q_laneu64-1.c new file mode 100644 index 000000000..5f4c927b6 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/neon/vst1Q_laneu64-1.c @@ -0,0 +1,25 @@ +/* Test the `vst1Q_laneu64' ARM Neon intrinsic. */ + +/* Detect ICE in the case of unaligned memory address. */ + +/* { dg-do compile } */ +/* { dg-require-effective-target arm_neon_ok } */ +/* { dg-add-options arm_neon } */ + +#include "arm_neon.h" + +unsigned char dummy_store[1000]; + +void +foo (char* addr) +{ + uint8x16_t vdata = vld1q_u8 (addr); + vst1q_lane_u64 ((uint64_t*) &dummy_store, vreinterpretq_u64_u8 (vdata), 0); +} + +uint64_t +bar (uint64x2_t vdata) +{ + vdata = vld1q_lane_u64 ((uint64_t*) &dummy_store, vdata, 0); + return vgetq_lane_u64 (vdata, 0); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/pr54300.C b/gcc-4.8/gcc/testsuite/gcc.target/arm/pr54300.C new file mode 100644 index 000000000..eb1a74e36 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/pr54300.C @@ -0,0 +1,61 @@ +/* { dg-do run } */ +/* { dg-require-effective-target arm_neon } */ +/* { dg-options "-O2" } */ +/* { dg-add-options arm_neon } */ + +#include <arm_neon.h> +#include <stdlib.h> + +struct __attribute__ ((aligned(8))) _v16u8_ { + uint8x16_t val; + _v16u8_( const int16x8_t &src) { val = vreinterpretq_u8_s16(src); } + operator int16x8_t () const { return vreinterpretq_s16_u8(val); } +}; +typedef struct _v16u8_ v16u8; + +struct __attribute__ ((aligned(4))) _v8u8_ { + uint8x8_t val; + _v8u8_( const uint8x8_t &src) { val = src; } + operator int16x4_t () const { return vreinterpret_s16_u8(val); } +}; +typedef struct _v8u8_ v8u8; + +typedef v16u8 v8i16; +typedef int32x4_t v4i32; +typedef const short cv1i16; +typedef const unsigned char cv1u8; +typedef const v8i16 cv8i16; + +static inline __attribute__((always_inline)) v8u8 zero_64(){ return vdup_n_u8( 0 ); } + +static inline __attribute__((always_inline)) v8i16 loadlo_8i16( cv8i16* p ){ + return vcombine_s16( vld1_s16( (cv1i16 *)p ), zero_64() ); +} +static inline __attribute__((always_inline)) v8i16 _loadlo_8i16( cv8i16* p, int offset ){ + return loadlo_8i16( (cv8i16*)(&((cv1u8*)p)[offset]) ); +} + +void __attribute__((noinline)) +test(unsigned short *_Inp, int32_t *_Out, + unsigned int s1v, unsigned int dv0, + unsigned int smask_v) +{ + int32x4_t c = vdupq_n_s32(0); + + for(unsigned int sv=0 ; sv!=dv0 ; sv=(sv+s1v)&smask_v ) + { + int32x4_t s; + s = vmovl_s16( vget_low_s16( _loadlo_8i16( (cv8i16*) _Inp, sv ) ) ); + c = vaddq_s32( c, s ); + } + vst1q_s32( _Out, c ); +} + +main() +{ + unsigned short a[4] = {1, 2, 3, 4}; + int32_t b[4] = {0, 0, 0, 0}; + test(a, b, 1, 1, ~0); + if (b[0] != 1 || b[1] != 2 || b[2] != 3 || b[3] != 4) + abort(); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/pr57637.c b/gcc-4.8/gcc/testsuite/gcc.target/arm/pr57637.c new file mode 100644 index 000000000..2b9bfdded --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/pr57637.c @@ -0,0 +1,206 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -fno-inline" } */ + +typedef struct _GtkCssStyleProperty GtkCssStyleProperty; + +struct _GtkCssStyleProperty +{ + int *initial_value; + unsigned int id; + unsigned int inherit :1; + unsigned int animated :1; + unsigned int affects_size :1; + unsigned int affects_font :1; + + int * parse_value; + int * query_value; + int * assign_value; +}; + +void +g_assertion_message_expr (const char *domain, + const char *file, + int line, + const char *func, + const char *expr) __attribute__((__noreturn__)); + +void +g_assertion_message_expr (const char *domain, + const char *file, + int line, + const char *func, + const char *expr) +{ + __builtin_abort (); +} +int +get_id (GtkCssStyleProperty *property) +{ + return 1; +} +int +_gtk_css_style_property_get_type () +{ + return 1; +} + +GtkCssStyleProperty * +g_object_new (int object_type, + const char *first_property_name, + ...) +{ + return (GtkCssStyleProperty *) __builtin_malloc (sizeof (GtkCssStyleProperty)); +} + +typedef enum { + INHERIT = (1 << 0), + ANIMATED = (1 << 1), + RESIZE = (1 << 2), + FONT = (1 << 3) +} GtkStylePropertyFlags; + +int t = 0; +void +gtk_css_style_property_register (const char * name, + int expected_id, + int value_type, + int flags, + int *parse_value, + int *query_value, + int *assign_value, + int *initial_value) +{ + GtkCssStyleProperty *node; + + do + { + if (__builtin_expect (__extension__ ( + { + int _g_boolean_var_; + if (initial_value != ((void *)0)) + _g_boolean_var_ = 1; + else + _g_boolean_var_ = 0; + _g_boolean_var_; + }), + 1)) + ; + else + g_assertion_message_expr ("Gtk", + "gtkcssstylepropertyimpl.c", + 85, + ((const char*) (__PRETTY_FUNCTION__)), + "initial_value != NULL"); + } while (0); + + do + { + if (__builtin_expect (__extension__ ( + { + int _g_boolean_var_; + if (parse_value != ((void *)0)) + _g_boolean_var_ = 1; + else + _g_boolean_var_ = 0; + _g_boolean_var_; + }), + 1)) + ; + else + g_assertion_message_expr ("Gtk", + "gtkcssstylepropertyimpl.c", + 86, + ((const char*) (__PRETTY_FUNCTION__)), + "parse_value != NULL"); + } while (0); + + do + { + if (__builtin_expect (__extension__ ( + { + int _g_boolean_var_; + if (value_type == ((int) ((1) << (2))) + || query_value != ((void *)0)) + _g_boolean_var_ = 1; + else + _g_boolean_var_ = 0; + _g_boolean_var_; + }), + 1)) + ; + else + g_assertion_message_expr ("Gtk", + "gtkcssstylepropertyimpl.c", + 87, ((const char*) (__PRETTY_FUNCTION__)), + "value_type == NONE || query_value != NULL"); + } while (0); + + /* FLAGS is changed in a cond_exec instruction with pr57637. */ + if (flags == 15) + t = 15; + + do + { + if (__builtin_expect (__extension__ ( + { + int _g_boolean_var_; + if (value_type == ((1) << (2)) + || assign_value != ((void *)0)) + _g_boolean_var_ = 1; + else + _g_boolean_var_ = 0; + _g_boolean_var_; + }), + 1)) + ; + else + g_assertion_message_expr ("Gtk", + "gtkcssstylepropertyimpl.c", + 88, ((const char*) (__PRETTY_FUNCTION__)), + "value_type == NONE || assign_value != NULL"); + } while (0); + + node = g_object_new ((_gtk_css_style_property_get_type ()), + "value-type", value_type, + "affects-size", (flags & RESIZE) ? (0) : (!(0)), + "affects-font", (flags & FONT) ? (!(0)) : (0), + "animated", (flags & ANIMATED) ? (!(0)) : (0), + "inherit", (flags & INHERIT) ? (!(0)) : (0), + "initial-value", initial_value, + "name", name, + ((void *)0)); + + node->parse_value = parse_value; + node->query_value = query_value; + node->assign_value = assign_value; + + do + { + if (__builtin_expect (__extension__ ( + { + int _g_boolean_var_; + if (get_id (node) == expected_id) + _g_boolean_var_ = 1; + else + _g_boolean_var_ = 0; + _g_boolean_var_; + }), + 1)) + ; + else + g_assertion_message_expr ("Gtk", + "gtkcssstylepropertyimpl.c", + 106, + ((const char*) (__PRETTY_FUNCTION__)), + "get_id (node) == expected_id"); + } while (0); +} + +int main () +{ + gtk_css_style_property_register ("test", 1, 4, 15, &t, &t, &t, &t); + + if (t != 15) + __builtin_abort (); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/pr59826.c b/gcc-4.8/gcc/testsuite/gcc.target/arm/pr59826.c new file mode 100644 index 000000000..b7053e426 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/pr59826.c @@ -0,0 +1,35 @@ +/* { dg-do compile } */ +/* { dg-options "-mthumb -mcpu=cortex-m4 -fprefetch-loop-arrays -O2" } */ + +typedef struct genxWriter_rec * genxWriter; +typedef unsigned char * utf8; +typedef const unsigned char * constUtf8; + +int genxScrubText(genxWriter w, constUtf8 in, utf8 out) +{ + int problems = 0; + constUtf8 last = in; + + while (*in) + { + int c = genxNextUnicodeChar(&in); + if (c == -1) + { + problems++; + last = in; + continue; + } + + if (!isXMLChar(w, c)) + { + problems++; + last = in; + continue; + } + + while (last < in) + *out++ = *last++; + } + *out = 0; + return problems; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/require-pic-register-loc.c b/gcc-4.8/gcc/testsuite/gcc.target/arm/require-pic-register-loc.c new file mode 100644 index 000000000..bd85e8640 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/require-pic-register-loc.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-g -fPIC" } */ + +void *v; +void a (void *x) { } +void b (void) { } + /* line 7. */ +int /* line 8. */ +main (int argc) /* line 9. */ +{ /* line 10. */ + if (argc == 12345) /* line 11. */ + { + a (v); + return 1; + } + b (); + + return 0; +} + +/* { dg-final { scan-assembler-not "\.loc 1 7 0" } } */ +/* { dg-final { scan-assembler-not "\.loc 1 8 0" } } */ +/* { dg-final { scan-assembler-not "\.loc 1 9 0" } } */ + +/* The loc at the start of the prologue. */ +/* { dg-final { scan-assembler-times "\.loc 1 10 0" 1 } } */ + +/* The loc at the end of the prologue, with the first user line. */ +/* { dg-final { scan-assembler-times "\.loc 1 11 0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/thumb1-pic-high-reg.c b/gcc-4.8/gcc/testsuite/gcc.target/arm/thumb1-pic-high-reg.c new file mode 100644 index 000000000..df269fc84 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/thumb1-pic-high-reg.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_thumb1_ok } */ +/* { dg-options "-mthumb -fpic -mpic-register=9" } */ + +int g_test; + +int +foo (int par) +{ + g_test = par; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/thumb1-pic-single-base.c b/gcc-4.8/gcc/testsuite/gcc.target/arm/thumb1-pic-single-base.c new file mode 100644 index 000000000..6e9b2570a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/thumb1-pic-single-base.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_thumb1_ok } */ +/* { dg-options "-mthumb -fpic -msingle-pic-base" } */ + +int g_test; + +int +foo (int par) +{ + g_test = par; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/arm/vrinta-ce.c b/gcc-4.8/gcc/testsuite/gcc.target/arm/vrinta-ce.c new file mode 100644 index 000000000..71c5b3b0e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/arm/vrinta-ce.c @@ -0,0 +1,15 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_v8_vfp_ok } */ +/* { dg-options "-O2 -marm -march=armv8-a" } */ +/* { dg-add-options arm_v8_vfp } */ + +double foo (double a) +{ + if (a > 3.0) + return __builtin_round (a); + + return 0.0; +} + +/* { dg-final { scan-assembler-times "vrinta.f64\td\[0-9\]+" 1 } } */ + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/avr/pr60991.c b/gcc-4.8/gcc/testsuite/gcc.target/avr/pr60991.c new file mode 100644 index 000000000..a09f42a62 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/avr/pr60991.c @@ -0,0 +1,21 @@ +/* { dg-do run } */ +/* { dg-options "-O1" } */ + +/* This testcase (simplified from the original bug report) exposes + PR60991. The code generated for writing the __int24 value corrupts + the frame pointer if the offset is <= 63 + MAX_LD_OFFSET */ + +#include <stdlib.h> + +int main(void) +{ + volatile char junk[62]; + junk[0] = 5; + volatile __int24 staticConfig = 0; + + if (junk[0] != 5) + abort(); + + exit(0); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/avr/torture/pr61055.c b/gcc-4.8/gcc/testsuite/gcc.target/avr/torture/pr61055.c new file mode 100644 index 000000000..9dd1f427d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/avr/torture/pr61055.c @@ -0,0 +1,88 @@ +/* { dg-do run } */ +/* { dg-options { -fno-peephole2 } } */ + +#include <stdlib.h> + +typedef __UINT16_TYPE__ uint16_t; +typedef __INT16_TYPE__ int16_t; +typedef __UINT8_TYPE__ uint8_t; + +uint8_t __attribute__((noinline,noclone)) +fun_inc (uint8_t c0) +{ + register uint8_t c asm ("r15") = c0; + + /* Force target value into R15 (lower register) */ + asm ("" : "+l" (c)); + + c++; + if (c >= 0x80) + c = 0; + + asm ("" : "+l" (c)); + + return c; +} + +uint8_t __attribute__((noinline,noclone)) +fun_dec (uint8_t c0) +{ + register uint8_t c asm ("r15") = c0; + + /* Force target value into R15 (lower register) */ + asm ("" : "+l" (c)); + + c--; + if (c < 0x80) + c = 0; + + asm ("" : "+l" (c)); + + return c; +} + + +uint8_t __attribute__((noinline,noclone)) +fun_neg (uint8_t c0) +{ + register uint8_t c asm ("r15") = c0; + + c = -c; + if (c >= 0x80) + c = 0; + + return c; +} + +uint16_t __attribute__((noinline,noclone)) +fun_adiw (uint16_t c0) +{ + register uint16_t c asm ("r24") = c0; + + /* Force target value into R24 (for ADIW) */ + asm ("" : "+r" (c)); + + c += 2; + if (c >= 0x8000) + c = 0; + + asm ("" : "+r" (c)); + + return c; +} + + +int main() +{ + if (fun_inc (0x7f) != 0) + abort(); + + if (fun_neg (0x80) != 0) + abort(); + + if (fun_adiw (0x7ffe) != 0) + abort(); + + exit (0); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-1.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-1.c index d91212283..cc524c8a6 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-1.c @@ -15,7 +15,7 @@ void static avx_test (void) { union256d u; - double e [4] __attribute__ ((aligned (8))) = {41124.234,2344.2354,8653.65635,856.43576}; + double e [4] __attribute__ ((aligned (32))) = {41124.234,2344.2354,8653.65635,856.43576}; u.x = test (e); diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-2.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-2.c index 96a664ac1..9224484ca 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-2.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/avx-vmovapd-256-2.c @@ -15,7 +15,7 @@ void static avx_test (void) { union256d u; - double e [4] __attribute__ ((aligned (8))) = {0.0}; + double e [4] __attribute__ ((aligned (32))) = {0.0}; u.x = _mm256_set_pd (39578.467285, 7856.342941, 85632.783567, 47563.234215); diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/nest-1.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/nest-1.c new file mode 100644 index 000000000..ba75350fb --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/nest-1.c @@ -0,0 +1,14 @@ +/* { dg-do compile { target llp64 } } */ +/* { dg-options "" } */ + +void foo (int i) +{ + void nested (void) + { + char arr[(1U << 31) + 4U]; + arr[i] = 0; + } + + nested (); +} + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr30315.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr30315.c index 998d5071e..557b4f751 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr30315.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr30315.c @@ -1,6 +1,6 @@ /* { dg-do compile } */ /* { dg-options "-O2" } */ -/* { dg-final { scan-assembler-times "cmp" 4 } } */ +/* { dg-final { scan-assembler-not "cmp" } } */ extern void abort (void); int c; @@ -34,39 +34,10 @@ void pluscconly##t##C (T a, T b) \ } #define PLUSCCONLY(T, t) PLUSCCONLY1(T, t, a) PLUSCCONLY1(T, t, b) -#define MINUSCC(T, t) \ -T minuscc##t (T a, T b) \ -{ \ - T difference = a - b; \ - if (difference > a) \ - abort (); \ - return difference; \ -} - -#define DECCC(T, t) \ -T deccc##t (T a, T b) \ -{ \ - T difference = a - b; \ - if (difference > a) \ - c --; \ - return difference; \ -} - -#define MINUSCCONLY(T, t) \ -void minuscconly##t (T a, T b) \ -{ \ - T difference = a - b; \ - if (difference > a) \ - abort (); \ -} - #define TEST(T, t) \ PLUSCC(T, t) \ PLUSCCONLY(T, t) \ - INCCC(T, t) \ - MINUSCC(T, t) \ - MINUSCCONLY(T, t) \ - DECCC(T, t) + INCCC(T, t) TEST (unsigned long, l) TEST (unsigned int, i) @@ -84,14 +55,3 @@ unsigned long pluscczext##C (unsigned int a, unsigned int b) \ PLUSCCZEXT(a) PLUSCCZEXT(b) - -#define MINUSCCZEXT \ -unsigned long minuscczext (unsigned int a, unsigned int b) \ -{ \ - unsigned int difference = a - b; \ - if (difference > a) \ - abort (); \ - return difference; \ -} - -MINUSCCZEXT diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr39162.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr39162.c index c549106ad..efb46deae 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr39162.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr39162.c @@ -1,11 +1,14 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -Wno-psabi -msse2 -mno-avx" } */ +/* { dg-prune-output "ABI for passing parameters" } */ +/* { dg-options "-O2 -msse2 -mno-avx" } */ /* { dg-additional-options "-mabi=sysv" { target x86_64-*-mingw* } } */ typedef long long __m256i __attribute__ ((__vector_size__ (32), __may_alias__)); -__m256i +extern __m256i y; + +void bar (__m256i x) /* { dg-warning "AVX" "" } */ { - return x; + y = x; } diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr43546.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr43546.c new file mode 100644 index 000000000..53cb3a07f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr43546.c @@ -0,0 +1,12 @@ +/* PR target/43546 */ +/* { dg-do compile } */ +/* { dg-options "-O1" } */ +/* { dg-additional-options "-mpreferred-stack-boundary=2 -msseregparm -msse" { target ia32 } } */ + +extern void bar (double); + +void +foo (void) +{ + bar (1.0); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr54694.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr54694.c new file mode 100644 index 000000000..bcf82c2a1 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr54694.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +register void *hfp __asm__("%ebp"); /* { dg-message "note: for" } */ + +extern void g(void *); + +void f(int x) /* { dg-error "frame pointer required" } */ +{ + g(__builtin_alloca(x)); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr58137.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr58137.c new file mode 100644 index 000000000..0a7daf83c --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr58137.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -mavx2" } */ + +typedef unsigned int U32; + +struct sv { + void* sv_any; + U32 sv_refcnt; + U32 sv_flags; +}; +typedef struct sv SV; + +struct xrv { + SV * xrv_rv; +}; +typedef struct xrv XRV; + +extern XRV * PL_xrv_root; + +void +more_xrv (void) +{ + register XRV* xrv; + register XRV* xrvend; + xrv = PL_xrv_root; + xrvend = &xrv[200 / sizeof (XRV) - 1]; + while (xrv < xrvend) + { + xrv->xrv_rv = (SV*)(xrv + 1); + xrv++; + } + xrv->xrv_rv = 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr58690.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr58690.c new file mode 100644 index 000000000..87a87cc9c --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr58690.c @@ -0,0 +1,14 @@ +/* { dg-do compile { target { ! { ia32 } } } } */ +/* { dg-require-effective-target maybe_x32 } */ +/* { dg-options "-O2 -mx32 -maddress-mode=short" } */ + +struct gomp_thread +{ + char foo[41]; +}; +extern __thread struct gomp_thread gomp_tls_data; +void +foo (void) +{ + __builtin_memset (&gomp_tls_data, '\0', sizeof (gomp_tls_data)); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59021.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59021.c new file mode 100644 index 000000000..a1df27b10 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59021.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -mavx -mvzeroupper" } */ + +extern void abort (void); + +struct S { + int i1; + int i2; + int i3; +}; + +typedef double v4df __attribute__ ((vector_size (32))); + +extern int foo (v4df, int i1, int i2, int i3, int i4, int i5, struct S s); + +void bar (v4df v, struct S s) +{ + int r = foo (v, 1, 2, 3, 4, 5, s); + if (r) + abort (); +} + +/* { dg-final { scan-assembler-not "vzeroupper" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59034-1.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59034-1.c new file mode 100644 index 000000000..1f4c4e04a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59034-1.c @@ -0,0 +1,10 @@ +/* { dg-do compile { target { ! { ia32 } } } } */ +/* { dg-require-effective-target maybe_x32 } */ +/* { dg-options "-O -mx32 -mtune=corei7 -maddress-mode=short" } */ + +extern int foo(int, ...); +int bar(void) { + long double l = 1.2345E6; + foo(0, l); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59034-2.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59034-2.c new file mode 100644 index 000000000..14e594ba6 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59034-2.c @@ -0,0 +1,10 @@ +/* { dg-do compile { target { ! { ia32 } } } } */ +/* { dg-require-effective-target maybe_x32 } */ +/* { dg-options "-O -mx32 -mtune=corei7 -maddress-mode=long" } */ + +extern int foo(int, ...); +int bar(void) { + long double l = 1.2345E6; + foo(0, l); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59405.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59405.c new file mode 100644 index 000000000..1136e2e45 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59405.c @@ -0,0 +1,24 @@ +/* { dg-do run } */ +/* { dg-options "-mmmx -mfpmath=387" } */ + +#include "mmx-check.h" + +#include <mmintrin.h> + +typedef float float32x2_t __attribute__ ((vector_size (8))); + +float +foo32x2_be (float32x2_t x) +{ + _mm_empty (); + return x[1]; +} + +static void +mmx_test (void) +{ + float32x2_t b = { 0.0f, 1.0f }; + + if (foo32x2_be (b) != 1.0f) + abort (); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59470.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59470.c new file mode 100644 index 000000000..0d9952fb4 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59470.c @@ -0,0 +1,17 @@ +/* PR middle-end/58956 */ +/* PR middle-end/59470 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +int a, b, d[1024]; + +int +main () +{ + int c = a; + asm ("{movl $6, (%2); movl $1, %0|mov dword ptr [%2], 6; mov %0, 1}" + : "=r" (d[c]) : "rm" (b), "r" (&a) : "memory"); + if (d[0] != 1 || d[6] != 0) + __builtin_abort (); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59625.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59625.c new file mode 100644 index 000000000..8e1a7794b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59625.c @@ -0,0 +1,36 @@ +/* PR target/59625 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mtune=atom" } */ + +int +foo (void) +{ + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + asm goto ("" : : : : lab); + return 0; +lab: + return 1; +} + +/* Verify we don't consider asm goto as a jump for four jumps limit + optimization. asm goto doesn't have to contain a jump at all, + the branching to labels can happen through different means. */ +/* { dg-final { scan-assembler-not "(p2align\[^\n\r\]*\[\n\r]*\[^\n\r\]*){8}p2align" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-1.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-1.c new file mode 100644 index 000000000..46bff0181 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-1.c @@ -0,0 +1,15 @@ +/* PR target/59794 */ +/* { dg-do compile { target { ia32 } } } */ +/* { dg-options "-O2 -mno-mmx" } */ +/* { dg-skip-if "no MMX vector" { *-*-mingw* } } */ + +typedef int __v2si __attribute__ ((__vector_size__ (8))); + +extern __v2si x; + +extern void bar (__v2si); +void +foo (void) +{ + bar (x); /* { dg-message "warning: MMX vector argument without MMX enabled changes the ABI" } */ +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-2.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-2.c new file mode 100644 index 000000000..f13998214 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-2.c @@ -0,0 +1,15 @@ +/* PR target/59794 */ +/* { dg-prune-output "ABI for passing parameters" } */ +/* { dg-options "-O2 -mno-sse" } */ +/* { dg-skip-if "no SSE vector" { *-*-mingw* } } */ + +typedef double __v2df __attribute__ ((__vector_size__ (16))); + +extern __v2df x; + +extern void bar (__v2df); +void +foo (void) +{ + bar (x); /* { dg-message "warning: SSE vector argument without SSE enabled changes the ABI" } */ +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-3.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-3.c new file mode 100644 index 000000000..a65893c63 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-3.c @@ -0,0 +1,15 @@ +/* PR target/59794 */ +/* { dg-prune-output "ABI for passing parameters" } */ +/* { dg-options "-O2 -mno-avx" } */ +/* { dg-skip-if "no AVX vector" { *-*-mingw* } } */ + +typedef int __v8si __attribute__ ((__vector_size__ (32))); + +extern __v8si x; + +extern void bar (__v8si); +void +foo (void) +{ + bar (x); /* { dg-message "warning: AVX vector argument without AVX enabled changes the ABI" } */ +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-4.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-4.c new file mode 100644 index 000000000..5ad0b070a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-4.c @@ -0,0 +1,14 @@ +/* PR target/59794 */ +/* { dg-do compile { target { ia32 } } } */ +/* { dg-options "-O2 -mno-mmx" } */ +/* { dg-skip-if "no MMX vector" { *-*-mingw* } } */ + +typedef int __v2si __attribute__ ((__vector_size__ (8))); + +extern __v2si x; + +__v2si +foo (void) +{ /* { dg-warning "MMX vector return without MMX enabled changes the ABI" } */ + return x; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-5.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-5.c new file mode 100644 index 000000000..24c88be09 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-5.c @@ -0,0 +1,14 @@ +/* PR target/59794 */ +/* { dg-do compile { target { ia32 } } } */ +/* { dg-options "-O2 -mno-sse" } */ +/* { dg-skip-if "no SSE vector" { *-*-mingw* } } */ + +typedef int __v4si __attribute__ ((__vector_size__ (16))); + +extern __v4si x; + +__v4si +foo (void) +{ /* { dg-warning "SSE vector return without SSE enabled changes the ABI" } */ + return x; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-6.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-6.c new file mode 100644 index 000000000..c809f9579 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-6.c @@ -0,0 +1,14 @@ +/* PR target/59794 */ +/* { dg-do compile { target { ! ia32 } } } */ +/* { dg-options "-O2 -mno-sse" } */ +/* { dg-skip-if "no SSE vector" { *-*-mingw* } } */ + +typedef int __v4si __attribute__ ((__vector_size__ (16))); + +extern __v4si x; + +__v4si +foo (void) +{ /* { dg-error "SSE register return with SSE disabled" } */ + return x; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-7.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-7.c new file mode 100644 index 000000000..57fd3d276 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59794-7.c @@ -0,0 +1,13 @@ +/* PR target/59794 */ +/* { dg-options "-O2 -mno-avx" } */ +/* { dg-skip-if "no AVX vector" { *-*-mingw* } } */ + +typedef int __v8si __attribute__ ((__vector_size__ (32))); + +extern __v8si x; + +__v8si +foo (void) +{ /* { dg-warning "AVX vector return without AVX enabled changes the ABI" } */ + return x; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59839.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59839.c new file mode 100644 index 000000000..dfb89456f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59839.c @@ -0,0 +1,12 @@ +/* PR target/59839 */ +/* { dg-do compile } */ +/* { dg-options "-O0 -mavx2" } */ + +#include <x86intrin.h> + +void +test (const float *x) +{ + __m256i i = _mm256_set1_epi32 (1); + __m256 d = _mm256_i32gather_ps (x, i, 1); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59929.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59929.c new file mode 100644 index 000000000..4591dc4d6 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr59929.c @@ -0,0 +1,55 @@ +/* { dg-do run } */ +/* { dg-options "-O0 -mno-accumulate-outgoing-args" } */ +/* { dg-options "-O0 -mno-accumulate-outgoing-args -mx32 -maddress-mode=short" { target x32 } } */ + +void +__attribute__ ((noinline)) +test (float x1, float x2, float x3, float x4, float x5, float x6, + float x7, float x8, float x9, float x10, float x11, float x12, + float x13, float x14, float x15, float x16) +{ + if (x1 != 91 + || x2 != 92 + || x3 != 93 + || x4 != 94 + || x5 != 95 + || x6 != 96 + || x7 != 97 + || x8 != 98 + || x9 != 99 + || x10 != 100 + || x11 != 101 + || x12 != 102 + || x13 != 103 + || x14 != 104 + || x15 != 105 + || x16 != 106) + __builtin_abort (); +} + +float x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, + x14, x15, x16; + +int +main () +{ + x1 = 91; + x2 = 92; + x3 = 93; + x4 = 94; + x5 = 95; + x6 = 96; + x7 = 97; + x8 = 98; + x9 = 99; + x10 = 100; + x11 = 101; + x12 = 102; + x13 = 103; + x14 = 104; + x15 = 105; + x16 = 106; + test (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, + x14, x15, x16); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60516.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60516.c new file mode 100644 index 000000000..575c8b61d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60516.c @@ -0,0 +1,20 @@ +/* PR target/60516 */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +struct S { char c[65536]; }; + +__attribute__((ms_abi, thiscall)) void +foo (void *x, struct S y) +{ +} + +__attribute__((ms_abi, fastcall)) void +bar (void *x, void *y, struct S z) +{ +} + +__attribute__((ms_abi, stdcall)) void +baz (struct S x) +{ +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60693.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60693.c new file mode 100644 index 000000000..e6033a783 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60693.c @@ -0,0 +1,13 @@ +/* PR target/60693 */ +/* { dg-do compile } */ +/* { dg-options "-O0" } */ + +void bar (char *); + +void +foo (void) +{ + char buf[4096]; + __builtin_memcpy (buf, (void *) 0x8000, 4096); + bar (buf); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60700.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60700.c new file mode 100644 index 000000000..5428f3616 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60700.c @@ -0,0 +1,59 @@ +/* PR rtl-optimization/60700 */ +/* { dg-do run { target ia32 } } */ +/* { dg-options "-O3 -march=i686" } */ + +int +__attribute__((noinline)) +foo (void) +{ + return 0; +} + +void *g = (void *)1; + +struct st { + char data[36]; /* must be greater than 32. */ +}; + +int +__attribute__((noinline)) +repro(struct st **out) +{ + int status = 0; + + *out = 0; + + status = foo(); + if (status != 0) { + return status; + } + + if (0 == g) { + status = 999; + return status; + } + + *out = (struct st *)__builtin_malloc(sizeof(struct st)); + if (0 == *out) { + status = 42; + return status; + } + + __builtin_memset(*out, 0, sizeof(struct st)); + + return status; +} + +int +main () +{ + struct st *p; + int ret = repro (&p); + unsigned int i; + + for (i = 0; i < sizeof (p->data)/sizeof (p->data[0]); i++) + if (p->data[i] != 0) + __builtin_abort (); + + return ret; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60909-1.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60909-1.c new file mode 100644 index 000000000..5a1ac3c0f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60909-1.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-mrdrnd" } */ + +extern void bar (int); + +void +foo (unsigned *u) +{ + int i = __builtin_ia32_rdrand32_step (u); + bar (i); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60909-2.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60909-2.c new file mode 100644 index 000000000..dd356685b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr60909-2.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-mrdseed" } */ + +extern void bar (int); + +void +foo (unsigned *u) +{ + int i = __builtin_ia32_rdseed_si_step (u); + bar (i); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr9771-1.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr9771-1.c index 38586fe97..daad319c3 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/i386/pr9771-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/pr9771-1.c @@ -45,7 +45,17 @@ void test(void) exit(0); } -int main() +/* main usually performs dynamic realignment of the stack in case + _start would fail to properly align the stack, but for dynamic + stack realignment we need frame pointer which is incompatible + with -ffixed-ebp and the global register var. So, cheat here + and hide from the compiler that main is really main. */ +#define ASMNAME(cname) ASMNAME2 (__USER_LABEL_PREFIX__, cname) +#define ASMNAME2(prefix, cname) STRING (prefix) cname +#define STRING(x) #x +int real_main() __asm (ASMNAME ("main")); + +int real_main() { test(); return 0; diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-1.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-1.c index b8b9dba0c..55d9f594f 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-1.c @@ -25,7 +25,7 @@ static void TEST (void) { union128d u; - double e[2] __attribute__ ((aligned (8))) = {2134.3343,1234.635654}; + double e[2] __attribute__ ((aligned (16))) = {2134.3343,1234.635654}; u.x = test (e); diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-2.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-2.c index 8298551ba..87da33277 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-2.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/sse2-movapd-2.c @@ -25,7 +25,7 @@ static void TEST (void) { union128d u; - double e[2] __attribute__ ((aligned (8))) = {0.0}; + double e[2] __attribute__ ((aligned (16))) = {0.0}; u.x = _mm_set_pd (2134.3343,1234.635654); diff --git a/gcc-4.8/gcc/testsuite/gcc.target/i386/xop-frczX.c b/gcc-4.8/gcc/testsuite/gcc.target/i386/xop-frczX.c new file mode 100644 index 000000000..931b5ce39 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/i386/xop-frczX.c @@ -0,0 +1,60 @@ +/* { dg-do run } */ +/* { dg-require-effective-target xop } */ +/* { dg-options "-O2 -mxop" } */ + +#include "xop-check.h" + +#include <x86intrin.h> + +void +check_mm_vmfrcz_sd (__m128d __A, __m128d __B) +{ + union128d a, b, c; + double d[2]; + + a.x = __A; + b.x = __B; + c.x = _mm_frcz_sd (__A, __B); + d[0] = b.a[0] - (int)b.a[0] ; + d[1] = a.a[1]; + if (check_union128d (c, d)) + abort (); +} + +void +check_mm_vmfrcz_ss (__m128 __A, __m128 __B) +{ + union128 a, b, c; + float f[4]; + + a.x = __A; + b.x = __B; + c.x = _mm_frcz_ss (__A, __B); + f[0] = b.a[0] - (int)b.a[0] ; + f[1] = a.a[1]; + f[2] = a.a[2]; + f[3] = a.a[3]; + if (check_union128 (c, f)) + abort (); +} + +static void +xop_test (void) +{ + union128 a, b; + union128d c,d; + int i; + + for (i = 0; i < 4; i++) + { + a.a[i] = i + 3.5; + b.a[i] = i + 7.9; + } + for (i = 0; i < 2; i++) + { + c.a[i] = i + 3.5; + d.a[i] = i + 7.987654321; + } + check_mm_vmfrcz_ss (a.x, b.x); + check_mm_vmfrcz_sd (c.x, d.x); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/microblaze/isa/fcmp4.c b/gcc-4.8/gcc/testsuite/gcc.target/microblaze/isa/fcmp4.c new file mode 100644 index 000000000..79cc5f9dd --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/microblaze/isa/fcmp4.c @@ -0,0 +1,9 @@ +/* { dg-options "-O3 -mcpu=v6.00.a -mhard-float" } */ + +void float_func(float f1, float f2, float f3) +{ + /* { dg-final { scan-assembler "fcmp\.eq\tr(\[0-9]\|\[1-2]\[0-9]\|3\[0-1]),r(\[0-9]\|\[1-2]\[0-9]\|3\[0-1]),r(\[0-9]\|\[1-2]\[0-9]\|3\[0-1])\[^0-9]" } } */ + /* { dg-final { scan-assembler "fcmp\.le\tr(\[0-9]\|\[1-2]\[0-9]\|3\[0-1]),r(\[0-9]\|\[1-2]\[0-9]\|3\[0-1]),r(\[0-9]\|\[1-2]\[0-9]\|3\[0-1])\[^0-9]" } } */ + if(f1==f2 && f1<=f3) + print ("f1 eq f2 && f1 le f3"); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/microblaze/others/builtin-trap.c b/gcc-4.8/gcc/testsuite/gcc.target/microblaze/others/builtin-trap.c new file mode 100644 index 000000000..fdcde1fa7 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/microblaze/others/builtin-trap.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ + +void trap () +{ + __builtin_trap (); +} + +/* { dg-final { scan-assembler "brki\tr0,-1" } } */
\ No newline at end of file diff --git a/gcc-4.8/gcc/testsuite/gcc.target/microblaze/others/mem_reload.c b/gcc-4.8/gcc/testsuite/gcc.target/microblaze/others/mem_reload.c new file mode 100644 index 000000000..e285fb821 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/microblaze/others/mem_reload.c @@ -0,0 +1,74 @@ +/* { dg-options "-O2 -fPIC" } */ + +typedef struct test_struct +{ + unsigned long long h[8]; + unsigned long long Nl,Nh; + union { + unsigned long long d[16]; + unsigned char p[(16*8)]; + } u; + unsigned int num,md_len; +} TEST_STRUCT; + +static const unsigned long long K512[12] = { + 0x428a2f98d728ae22,0x7137449123ef65cd, + 0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc, + 0x3956c25bf348b538,0x59f111f1b605d019, + 0x923f82a4af194f9b,0xab1c5ed5da6d8118, + 0xd807aa98a3030242,0x12835b0145706fbe, + 0x243185be4ee4b28c,0x550c7dc3d5ffb4e2}; + +#define ROTR(x,s) (((x)>>s) | (x)<<(64-s)) +#define Sigma0(x) (ROTR((x),28) ^ ROTR((x),34) ^ ROTR((x),39)) +#define Sigma1(x) (ROTR((x),14) ^ ROTR((x),18) ^ ROTR((x),41)) +#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z))) +#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) + +#define ROUND_00_15(i,a,b,c,d,e,f,g,h) do { \ + T1 += h + Sigma1(e) + Ch(e,f,g) + K512[i]; \ + h = Sigma0(a) + Maj(a,b,c); \ + d += T1; h += T1; } while (0) + +#define ROUND_16_80(i,a,b,c,d,e,f,g,h,X) do { \ + T1 = X[(i)&0x0f] += s0 + s1 + X[(i+9)&0x0f]; \ + ROUND_00_15(i,a,b,c,d,e,f,g,h); } while (0) + +static void testfunc1 (TEST_STRUCT *ctx, const void *in, unsigned int num) +{ + const unsigned long long *W=in; + unsigned long long a,b,c,d,e,f,g,h,s0,s1,T1; + unsigned long long X[16]; + int i; + + while (num--) { + + T1 = X[0] = W[0]; ROUND_00_15(0,a,b,c,d,e,f,g,h); + T1 = X[1] = W[1]; ROUND_00_15(1,h,a,b,c,d,e,f,g); + T1 = X[2] = W[2]; ROUND_00_15(2,g,h,a,b,c,d,e,f); + T1 = X[3] = W[3]; ROUND_00_15(3,f,g,h,a,b,c,d,e); + T1 = X[4] = W[4]; ROUND_00_15(4,e,f,g,h,a,b,c,d); + T1 = X[5] = W[5]; ROUND_00_15(5,d,e,f,g,h,a,b,c); + T1 = X[6] = W[6]; ROUND_00_15(6,c,d,e,f,g,h,a,b); + T1 = X[7] = W[7]; ROUND_00_15(7,b,c,d,e,f,g,h,a); + T1 = X[8] = W[8]; ROUND_00_15(8,a,b,c,d,e,f,g,h); + T1 = X[9] = W[9]; ROUND_00_15(9,h,a,b,c,d,e,f,g); + + for (i=16;i<80;i+=8) + { + ROUND_16_80(i+0,a,b,c,d,e,f,g,h,X); + } + + ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h; + } +} + +int testfunc2 (TEST_STRUCT *c, const void *_data, unsigned int len) +{ + const unsigned char *data=(const unsigned char *)_data; + + unsigned char *p=(unsigned char *)c->u.p; + + testfunc1 (c,p,0); + testfunc1 (c,data,len/sizeof(c->u)); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-1.c b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-1.c new file mode 100644 index 000000000..24016f269 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-1.c @@ -0,0 +1,10 @@ +/* { dg-options "isa_rev>=2" } */ +/* { dg-skip-if "bswap recognition needs expensive optimizations" { *-*-* } { "-O0" "-O1" } { "" } } */ + +NOMIPS16 unsigned short +foo (unsigned short x) +{ + return ((x << 8) & 0xff00) | ((x >> 8) & 0xff); +} + +/* { dg-final { scan-assembler "\twsbh\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-2.c b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-2.c new file mode 100644 index 000000000..e0ca496b6 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-2.c @@ -0,0 +1,9 @@ +/* { dg-options "isa_rev>=2" } */ + +NOMIPS16 unsigned short +foo (unsigned short x) +{ + return __builtin_bswap16 (x); +} + +/* { dg-final { scan-assembler "\twsbh\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-3.c b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-3.c new file mode 100644 index 000000000..5d2086fd3 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-3.c @@ -0,0 +1,14 @@ +/* { dg-options "isa_rev>=2" } */ +/* { dg-skip-if "bswap recognition needs expensive optimizations" { *-*-* } { "-O0" "-O1" } { "" } } */ + +NOMIPS16 unsigned int +foo (unsigned int x) +{ + return (((x << 24) & 0xff000000) + | ((x << 8) & 0xff0000) + | ((x >> 8) & 0xff00) + | ((x >> 24) & 0xff)); +} + +/* { dg-final { scan-assembler "\twsbh\t" } } */ +/* { dg-final { scan-assembler "\tror\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-4.c b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-4.c new file mode 100644 index 000000000..ac37a0114 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-4.c @@ -0,0 +1,10 @@ +/* { dg-options "isa_rev>=2" } */ + +NOMIPS16 unsigned int +foo (unsigned int x) +{ + return __builtin_bswap32 (x); +} + +/* { dg-final { scan-assembler "\twsbh\t" } } */ +/* { dg-final { scan-assembler "\tror\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-5.c b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-5.c new file mode 100644 index 000000000..45520e4ab --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-5.c @@ -0,0 +1,20 @@ +/* { dg-options "isa_rev>=2 -mgp64" } */ +/* { dg-skip-if "bswap recognition needs expensive optimizations" { *-*-* } { "-O0" "-O1" } { "" } } */ + +typedef unsigned long long uint64_t; + +NOMIPS16 uint64_t +foo (uint64_t x) +{ + return (((x << 56) & 0xff00000000000000ull) + | ((x << 40) & 0xff000000000000ull) + | ((x << 24) & 0xff0000000000ull) + | ((x << 8) & 0xff00000000ull) + | ((x >> 8) & 0xff000000) + | ((x >> 24) & 0xff0000) + | ((x >> 40) & 0xff00) + | ((x >> 56) & 0xff)); +} + +/* { dg-final { scan-assembler "\tdsbh\t" } } */ +/* { dg-final { scan-assembler "\tdshd\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-6.c b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-6.c new file mode 100644 index 000000000..1145357fe --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/mips/bswap-6.c @@ -0,0 +1,12 @@ +/* { dg-options "isa_rev>=2 -mgp64" } */ + +typedef unsigned long long uint64_t; + +NOMIPS16 uint64_t +foo (uint64_t x) +{ + return __builtin_bswap64 (x); +} + +/* { dg-final { scan-assembler "\tdsbh\t" } } */ +/* { dg-final { scan-assembler "\tdshd\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/mips/pr59137.c b/gcc-4.8/gcc/testsuite/gcc.target/mips/pr59137.c new file mode 100644 index 000000000..898650656 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/mips/pr59137.c @@ -0,0 +1,34 @@ +/* { dg-do run } */ +/* { dg-options "-mno-plt" } */ + +extern void abort (void); + +struct lispstruct +{ + int e; + int t; +}; + +struct lispstruct Cnil_body; +struct lispstruct Ct_body; +int nvalues; + +struct lispstruct * __attribute__ ((noinline)) +fLlistp (struct lispstruct *x0) +{ + if (x0 == &Cnil_body + || (((unsigned long) x0 >= 0x80000000) ? 0 + : (!x0->e ? (x0 != &Cnil_body) : x0->t))) + x0 = &Ct_body; + else + x0 = &Cnil_body; + nvalues = 1; + return x0; +} + +int main () +{ + if (fLlistp ((struct lispstruct *) 0xa0000001) != &Cnil_body) + abort (); + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/altivec-perm-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/altivec-perm-1.c index ee5c5eee9..c3cf67e44 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/altivec-perm-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/altivec-perm-1.c @@ -19,19 +19,6 @@ V b4(V x) return __builtin_shuffle(x, (V){ 4,5,6,7, 4,5,6,7, 4,5,6,7, 4,5,6,7, }); } -V p2(V x, V y) -{ - return __builtin_shuffle(x, y, - (V){ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31 }); - -} - -V p4(V x, V y) -{ - return __builtin_shuffle(x, y, - (V){ 2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31 }); -} - V h1(V x, V y) { return __builtin_shuffle(x, y, @@ -72,5 +59,3 @@ V l4(V x, V y) /* { dg-final { scan-assembler "vspltb" } } */ /* { dg-final { scan-assembler "vsplth" } } */ /* { dg-final { scan-assembler "vspltw" } } */ -/* { dg-final { scan-assembler "vpkuhum" } } */ -/* { dg-final { scan-assembler "vpkuwum" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/altivec-perm-3.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/altivec-perm-3.c new file mode 100644 index 000000000..d0b671eac --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/altivec-perm-3.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target powerpc_altivec_ok } */ +/* { dg-skip-if "" { powerpc*le-*-* } { "*" } { "" } } */ +/* { dg-options "-O -maltivec -mno-vsx" } */ + +typedef unsigned char V __attribute__((vector_size(16))); + +V p2(V x, V y) +{ + return __builtin_shuffle(x, y, + (V){ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31 }); + +} + +V p4(V x, V y) +{ + return __builtin_shuffle(x, y, + (V){ 2, 3, 6, 7, 10, 11, 14, 15, 18, 19, 22, 23, 26, 27, 30, 31 }); +} + +/* { dg-final { scan-assembler-not "vperm" } } */ +/* { dg-final { scan-assembler "vpkuhum" } } */ +/* { dg-final { scan-assembler "vpkuwum" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic-p7.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic-p7.c new file mode 100644 index 000000000..3442bfba4 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic-p7.c @@ -0,0 +1,207 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mcpu=power7 -O2" } */ +/* { dg-final { scan-assembler-not "lbarx" } } */ +/* { dg-final { scan-assembler-not "lharx" } } */ +/* { dg-final { scan-assembler-times "lwarx" 18 } } */ +/* { dg-final { scan-assembler-times "ldarx" 6 } } */ +/* { dg-final { scan-assembler-not "lqarx" } } */ +/* { dg-final { scan-assembler-not "stbcx" } } */ +/* { dg-final { scan-assembler-not "sthcx" } } */ +/* { dg-final { scan-assembler-times "stwcx" 18 } } */ +/* { dg-final { scan-assembler-times "stdcx" 6 } } */ +/* { dg-final { scan-assembler-not "stqcx" } } */ +/* { dg-final { scan-assembler-times "bl __atomic" 6 } } */ +/* { dg-final { scan-assembler-times "isync" 12 } } */ +/* { dg-final { scan-assembler-times "lwsync" 8 } } */ +/* { dg-final { scan-assembler-not "mtvsrd" } } */ +/* { dg-final { scan-assembler-not "mtvsrwa" } } */ +/* { dg-final { scan-assembler-not "mtvsrwz" } } */ +/* { dg-final { scan-assembler-not "mfvsrd" } } */ +/* { dg-final { scan-assembler-not "mfvsrwz" } } */ + +/* Test for the byte atomic operations on power8 using lbarx/stbcx. */ +char +char_fetch_add_relaxed (char *ptr, int value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +char +char_fetch_sub_consume (char *ptr, int value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +char +char_fetch_and_acquire (char *ptr, int value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +char +char_fetch_ior_release (char *ptr, int value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +char +char_fetch_xor_acq_rel (char *ptr, int value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +char +char_fetch_nand_seq_cst (char *ptr, int value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +/* Test for the half word atomic operations on power8 using lharx/sthcx. */ +short +short_fetch_add_relaxed (short *ptr, int value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +short +short_fetch_sub_consume (short *ptr, int value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +short +short_fetch_and_acquire (short *ptr, int value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +short +short_fetch_ior_release (short *ptr, int value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +short +short_fetch_xor_acq_rel (short *ptr, int value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +short +short_fetch_nand_seq_cst (short *ptr, int value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +/* Test for the word atomic operations on power8 using lwarx/stwcx. */ +int +int_fetch_add_relaxed (int *ptr, int value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +int +int_fetch_sub_consume (int *ptr, int value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +int +int_fetch_and_acquire (int *ptr, int value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +int +int_fetch_ior_release (int *ptr, int value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +int +int_fetch_xor_acq_rel (int *ptr, int value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +int +int_fetch_nand_seq_cst (int *ptr, int value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +/* Test for the double word atomic operations on power8 using ldarx/stdcx. */ +long +long_fetch_add_relaxed (long *ptr, long value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +long +long_fetch_sub_consume (long *ptr, long value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +long +long_fetch_and_acquire (long *ptr, long value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +long +long_fetch_ior_release (long *ptr, long value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +long +long_fetch_xor_acq_rel (long *ptr, long value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +long +long_fetch_nand_seq_cst (long *ptr, long value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +/* Test for the quad word atomic operations on power8 using ldarx/stdcx. */ +__int128_t +quad_fetch_add_relaxed (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +__int128_t +quad_fetch_sub_consume (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +__int128_t +quad_fetch_and_acquire (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +__int128_t +quad_fetch_ior_release (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +__int128_t +quad_fetch_xor_acq_rel (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +__int128_t +quad_fetch_nand_seq_cst (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic-p8.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic-p8.c new file mode 100644 index 000000000..17460ac4c --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic-p8.c @@ -0,0 +1,237 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler-times "lbarx" 7 } } */ +/* { dg-final { scan-assembler-times "lharx" 7 } } */ +/* { dg-final { scan-assembler-times "lwarx" 7 } } */ +/* { dg-final { scan-assembler-times "ldarx" 7 } } */ +/* { dg-final { scan-assembler-times "lqarx" 7 } } */ +/* { dg-final { scan-assembler-times "stbcx" 7 } } */ +/* { dg-final { scan-assembler-times "sthcx" 7 } } */ +/* { dg-final { scan-assembler-times "stwcx" 7 } } */ +/* { dg-final { scan-assembler-times "stdcx" 7 } } */ +/* { dg-final { scan-assembler-times "stqcx" 7 } } */ +/* { dg-final { scan-assembler-not "bl __atomic" } } */ +/* { dg-final { scan-assembler-times "isync" 20 } } */ +/* { dg-final { scan-assembler-times "lwsync" 10 } } */ +/* { dg-final { scan-assembler-not "mtvsrd" } } */ +/* { dg-final { scan-assembler-not "mtvsrwa" } } */ +/* { dg-final { scan-assembler-not "mtvsrwz" } } */ +/* { dg-final { scan-assembler-not "mfvsrd" } } */ +/* { dg-final { scan-assembler-not "mfvsrwz" } } */ + +/* Test for the byte atomic operations on power8 using lbarx/stbcx. */ +char +char_fetch_add_relaxed (char *ptr, int value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +char +char_fetch_sub_consume (char *ptr, int value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +char +char_fetch_and_acquire (char *ptr, int value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +char +char_fetch_ior_release (char *ptr, int value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +char +char_fetch_xor_acq_rel (char *ptr, int value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +char +char_fetch_nand_seq_cst (char *ptr, int value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +void +char_val_compare_and_swap (char *p, int i, int j, char *q) +{ + *q = __sync_val_compare_and_swap (p, i, j); +} + +/* Test for the half word atomic operations on power8 using lharx/sthcx. */ +short +short_fetch_add_relaxed (short *ptr, int value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +short +short_fetch_sub_consume (short *ptr, int value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +short +short_fetch_and_acquire (short *ptr, int value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +short +short_fetch_ior_release (short *ptr, int value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +short +short_fetch_xor_acq_rel (short *ptr, int value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +short +short_fetch_nand_seq_cst (short *ptr, int value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +void +short_val_compare_and_swap (short *p, int i, int j, short *q) +{ + *q = __sync_val_compare_and_swap (p, i, j); +} + +/* Test for the word atomic operations on power8 using lwarx/stwcx. */ +int +int_fetch_add_relaxed (int *ptr, int value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +int +int_fetch_sub_consume (int *ptr, int value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +int +int_fetch_and_acquire (int *ptr, int value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +int +int_fetch_ior_release (int *ptr, int value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +int +int_fetch_xor_acq_rel (int *ptr, int value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +int +int_fetch_nand_seq_cst (int *ptr, int value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +void +int_val_compare_and_swap (int *p, int i, int j, int *q) +{ + *q = __sync_val_compare_and_swap (p, i, j); +} + +/* Test for the double word atomic operations on power8 using ldarx/stdcx. */ +long +long_fetch_add_relaxed (long *ptr, long value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +long +long_fetch_sub_consume (long *ptr, long value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +long +long_fetch_and_acquire (long *ptr, long value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +long +long_fetch_ior_release (long *ptr, long value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +long +long_fetch_xor_acq_rel (long *ptr, long value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +long +long_fetch_nand_seq_cst (long *ptr, long value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +void +long_val_compare_and_swap (long *p, long i, long j, long *q) +{ + *q = __sync_val_compare_and_swap (p, i, j); +} + +/* Test for the quad word atomic operations on power8 using ldarx/stdcx. */ +__int128_t +quad_fetch_add_relaxed (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_RELAXED); +} + +__int128_t +quad_fetch_sub_consume (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_sub (ptr, value, __ATOMIC_CONSUME); +} + +__int128_t +quad_fetch_and_acquire (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +__int128_t +quad_fetch_ior_release (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_RELEASE); +} + +__int128_t +quad_fetch_xor_acq_rel (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_xor (ptr, value, __ATOMIC_ACQ_REL); +} + +__int128_t +quad_fetch_nand_seq_cst (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_nand (ptr, value, __ATOMIC_SEQ_CST); +} + +void +quad_val_compare_and_swap (__int128_t *p, __int128_t i, __int128_t j, __int128_t *q) +{ + *q = __sync_val_compare_and_swap (p, i, j); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic_load_store-p8.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic_load_store-p8.c new file mode 100644 index 000000000..8a5cbfaa3 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/atomic_load_store-p8.c @@ -0,0 +1,22 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler-times "lq" 1 } } */ +/* { dg-final { scan-assembler-times "stq" 1 } } */ +/* { dg-final { scan-assembler-not "bl __atomic" } } */ +/* { dg-final { scan-assembler-not "lqarx" } } */ +/* { dg-final { scan-assembler-not "stqcx" } } */ + +__int128 +atomic_load_128_relaxed (__int128 *ptr) +{ + return __atomic_load_n (ptr, __ATOMIC_RELAXED); +} + +void +atomic_store_128_relaxed (__int128 *ptr, __int128 val) +{ + __atomic_store_n (ptr, val, __ATOMIC_RELAXED); +} + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-1.c new file mode 100644 index 000000000..c7496c235 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-1.c @@ -0,0 +1,27 @@ +/* { dg-do compile { target { powerpc*-*-linux* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mcpu=power7 -O2" } */ +/* { dg-final { scan-assembler-times "cdtbcd " 1 } } */ +/* { dg-final { scan-assembler-times "cbcdtd " 1 } } */ +/* { dg-final { scan-assembler-times "addg6s " 1 } } */ +/* { dg-final { scan-assembler-not "bl __builtin" } } */ + +unsigned int +to_bcd (unsigned int a) +{ + return __builtin_cdtbcd (a); +} + +unsigned int +from_bcd (unsigned int a) +{ + return __builtin_cbcdtd (a); +} + +unsigned int +bcd_arith (unsigned int a, unsigned int b) +{ + return __builtin_addg6s (a, b); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-2.c new file mode 100644 index 000000000..d330b7423 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-2.c @@ -0,0 +1,44 @@ +/* { dg-do compile { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler-times "bcdadd\[.\] " 2 } } */ +/* { dg-final { scan-assembler-times "bcdsub\[.\] " 2 } } */ +/* { dg-final { scan-assembler-not "bl __builtin" } } */ +/* { dg-final { scan-assembler-not "mtvsr" } } */ +/* { dg-final { scan-assembler-not "mfvsr" } } */ +/* { dg-final { scan-assembler-not "lvx" } } */ +/* { dg-final { scan-assembler-not "lxvw4x" } } */ +/* { dg-final { scan-assembler-not "lxvd2x" } } */ +/* { dg-final { scan-assembler-not "stvx" } } */ +/* { dg-final { scan-assembler-not "stxvw4x" } } */ +/* { dg-final { scan-assembler-not "stxvd2x" } } */ + +typedef __int128_t __attribute__((__vector_size__(16))) vector_128_t; +typedef __int128_t scalar_128_t; +typedef unsigned long long scalar_64_t; + +vector_128_t +do_add_0 (vector_128_t a, vector_128_t b) +{ + return __builtin_bcdadd (a, b, 0); +} + +vector_128_t +do_add_1 (vector_128_t a, vector_128_t b) +{ + return __builtin_bcdadd (a, b, 1); +} + +vector_128_t +do_sub_0 (vector_128_t a, vector_128_t b) +{ + return __builtin_bcdsub (a, b, 0); +} + +vector_128_t +do_sub_1 (vector_128_t a, vector_128_t b) +{ + return __builtin_bcdsub (a, b, 1); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-3.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-3.c new file mode 100644 index 000000000..436cecf6f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bcd-3.c @@ -0,0 +1,103 @@ +/* { dg-do compile { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler-times "bcdadd\[.\] " 4 } } */ +/* { dg-final { scan-assembler-times "bcdsub\[.\] " 4 } } */ +/* { dg-final { scan-assembler-not "bl __builtin" } } */ +/* { dg-final { scan-assembler-not "mtvsr" } } */ +/* { dg-final { scan-assembler-not "mfvsr" } } */ +/* { dg-final { scan-assembler-not "lvx" } } */ +/* { dg-final { scan-assembler-not "lxvw4x" } } */ +/* { dg-final { scan-assembler-not "lxvd2x" } } */ +/* { dg-final { scan-assembler-not "stvx" } } */ +/* { dg-final { scan-assembler-not "stxvw4x" } } */ +/* { dg-final { scan-assembler-not "stxvd2x" } } */ + +typedef __int128_t __attribute__((__vector_size__(16))) vector_128_t; +typedef __int128_t scalar_128_t; +typedef unsigned long long scalar_64_t; + +/* Test whether the peephole works to allow folding a bcdadd, with a + bcdadd_<test> into a single instruction. */ + +vector_128_t +do_add_lt (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdadd (a, b, 0); + if (__builtin_bcdadd_lt (a, b, 0)) + *p = 1; + + return ret; +} + +vector_128_t +do_add_eq (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdadd (a, b, 0); + if (__builtin_bcdadd_eq (a, b, 0)) + *p = 1; + + return ret; +} + +vector_128_t +do_add_gt (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdadd (a, b, 0); + if (__builtin_bcdadd_gt (a, b, 0)) + *p = 1; + + return ret; +} + +vector_128_t +do_add_ov (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdadd (a, b, 0); + if (__builtin_bcdadd_ov (a, b, 0)) + *p = 1; + + return ret; +} + +vector_128_t +do_sub_lt (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdsub (a, b, 0); + if (__builtin_bcdsub_lt (a, b, 0)) + *p = 1; + + return ret; +} + +vector_128_t +do_sub_eq (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdsub (a, b, 0); + if (__builtin_bcdsub_eq (a, b, 0)) + *p = 1; + + return ret; +} + +vector_128_t +do_sub_gt (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdsub (a, b, 0); + if (__builtin_bcdsub_gt (a, b, 0)) + *p = 1; + + return ret; +} + +vector_128_t +do_sub_ov (vector_128_t a, vector_128_t b, int *p) +{ + vector_128_t ret = __builtin_bcdsub (a, b, 0); + if (__builtin_bcdsub_ov (a, b, 0)) + *p = 1; + + return ret; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool.c new file mode 100644 index 000000000..f007db4b5 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool.c @@ -0,0 +1,14 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-options "-O2" } */ +/* { dg-final { scan-assembler "eqv" } } */ +/* { dg-final { scan-assembler "nand" } } */ +/* { dg-final { scan-assembler "nor" } } */ + +#ifndef TYPE +#define TYPE unsigned long +#endif + +TYPE op1 (TYPE a, TYPE b) { return ~(a ^ b); } /* eqv */ +TYPE op2 (TYPE a, TYPE b) { return ~(a & b); } /* nand */ +TYPE op3 (TYPE a, TYPE b) { return ~(a | b); } /* nor */ + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-av.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-av.c new file mode 100644 index 000000000..fc56ce261 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-av.c @@ -0,0 +1,32 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_altivec_ok } */ +/* { dg-options "-O2 -mcpu=power6 -maltivec" } */ +/* { dg-final { scan-assembler-not "\[ \t\]and " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]or " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]nor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]andc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]eqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]orc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]nand " } } */ +/* { dg-final { scan-assembler "\[ \t\]vand " } } */ +/* { dg-final { scan-assembler "\[ \t\]vandc " } } */ +/* { dg-final { scan-assembler "\[ \t\]vor " } } */ +/* { dg-final { scan-assembler "\[ \t\]vxor " } } */ +/* { dg-final { scan-assembler "\[ \t\]vnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxland " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxleqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlorc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnand " } } */ + +#ifndef TYPE +typedef int v4si __attribute__ ((vector_size (16))); +#define TYPE v4si +#endif + +#include "bool2.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p5.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p5.c new file mode 100644 index 000000000..e4810d00d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p5.c @@ -0,0 +1,32 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_altivec_ok } */ +/* { dg-options "-O2 -mcpu=power5 -mabi=altivec -mno-altivec -mno-vsx" } */ +/* { dg-final { scan-assembler "\[ \t\]and " } } */ +/* { dg-final { scan-assembler "\[ \t\]or " } } */ +/* { dg-final { scan-assembler "\[ \t\]xor " } } */ +/* { dg-final { scan-assembler "\[ \t\]nor " } } */ +/* { dg-final { scan-assembler "\[ \t\]andc " } } */ +/* { dg-final { scan-assembler "\[ \t\]eqv " } } */ +/* { dg-final { scan-assembler "\[ \t\]orc " } } */ +/* { dg-final { scan-assembler "\[ \t\]nand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxland " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxleqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlorc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnand " } } */ + +#ifndef TYPE +typedef int v4si __attribute__ ((vector_size (16))); +#define TYPE v4si +#endif + +#include "bool2.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p7.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p7.c new file mode 100644 index 000000000..274fcb090 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p7.c @@ -0,0 +1,31 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power7" } */ +/* { dg-final { scan-assembler-not "\[ \t\]and " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]or " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]nor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]eqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]andc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]orc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]nand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vnor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxland " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlxor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlnor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxleqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlorc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnand " } } */ + +#ifndef TYPE +typedef int v4si __attribute__ ((vector_size (16))); +#define TYPE v4si +#endif + +#include "bool2.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p8.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p8.c new file mode 100644 index 000000000..34f4d2df8 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2-p8.c @@ -0,0 +1,32 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-O2 -mcpu=power8" } */ +/* { dg-final { scan-assembler-not "\[ \t\]and " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]or " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]nor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]eqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]andc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]orc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]nand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vnor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxland " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlxor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlnor " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlandc " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxleqv " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlorc " } } */ +/* { dg-final { scan-assembler "\[ \t\]xxlnand " } } */ + +#ifndef TYPE +typedef int v4si __attribute__ ((vector_size (16))); +#define TYPE v4si +#endif + +#include "bool2.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2.h b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2.h new file mode 100644 index 000000000..4513944c2 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool2.h @@ -0,0 +1,29 @@ +/* Test various logical operations. */ + +TYPE arg1 (TYPE p, TYPE q) { return p & q; } /* AND */ +TYPE arg2 (TYPE p, TYPE q) { return p | q; } /* OR */ +TYPE arg3 (TYPE p, TYPE q) { return p ^ q; } /* XOR */ +TYPE arg4 (TYPE p) { return ~ p; } /* NOR */ +TYPE arg5 (TYPE p, TYPE q) { return ~(p & q); } /* NAND */ +TYPE arg6 (TYPE p, TYPE q) { return ~(p | q); } /* NOR */ +TYPE arg7 (TYPE p, TYPE q) { return ~(p ^ q); } /* EQV */ +TYPE arg8 (TYPE p, TYPE q) { return (~p) & q; } /* ANDC */ +TYPE arg9 (TYPE p, TYPE q) { return (~p) | q; } /* ORC */ +TYPE arg10(TYPE p, TYPE q) { return (~p) ^ q; } /* EQV */ +TYPE arg11(TYPE p, TYPE q) { return p & (~q); } /* ANDC */ +TYPE arg12(TYPE p, TYPE q) { return p | (~q); } /* ORC */ +TYPE arg13(TYPE p, TYPE q) { return p ^ (~q); } /* EQV */ + +void ptr1 (TYPE *p) { p[0] = p[1] & p[2]; } /* AND */ +void ptr2 (TYPE *p) { p[0] = p[1] | p[2]; } /* OR */ +void ptr3 (TYPE *p) { p[0] = p[1] ^ p[2]; } /* XOR */ +void ptr4 (TYPE *p) { p[0] = ~p[1]; } /* NOR */ +void ptr5 (TYPE *p) { p[0] = ~(p[1] & p[2]); } /* NAND */ +void ptr6 (TYPE *p) { p[0] = ~(p[1] | p[2]); } /* NOR */ +void ptr7 (TYPE *p) { p[0] = ~(p[1] ^ p[2]); } /* EQV */ +void ptr8 (TYPE *p) { p[0] = ~(p[1]) & p[2]; } /* ANDC */ +void ptr9 (TYPE *p) { p[0] = (~p[1]) | p[2]; } /* ORC */ +void ptr10(TYPE *p) { p[0] = (~p[1]) ^ p[2]; } /* EQV */ +void ptr11(TYPE *p) { p[0] = p[1] & (~p[2]); } /* ANDC */ +void ptr12(TYPE *p) { p[0] = p[1] | (~p[2]); } /* ORC */ +void ptr13(TYPE *p) { p[0] = p[1] ^ (~p[2]); } /* EQV */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-av.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-av.c new file mode 100644 index 000000000..d4aac786b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-av.c @@ -0,0 +1,37 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_altivec_ok } */ +/* { dg-options "-O2 -mcpu=power6 -mabi=altivec -maltivec -mno-vsx" } */ +/* { dg-final { scan-assembler "\[ \t\]and " } } */ +/* { dg-final { scan-assembler "\[ \t\]or " } } */ +/* { dg-final { scan-assembler "\[ \t\]xor " } } */ +/* { dg-final { scan-assembler "\[ \t\]nor " } } */ +/* { dg-final { scan-assembler "\[ \t\]andc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxland " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxleqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlorc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnand " } } */ + +/* On altivec, for 128-bit types, ORC/ANDC/EQV might not show up, since the + vector unit doesn't support these, so the appropriate combine patterns may + not be generated. */ + +#ifndef TYPE +#ifdef _ARCH_PPC64 +#define TYPE __int128_t +#else +typedef int v4si __attribute__ ((vector_size (16))); +#define TYPE v4si +#endif +#endif + +#include "bool3.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-p7.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-p7.c new file mode 100644 index 000000000..34e3c9e79 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-p7.c @@ -0,0 +1,37 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power7" } */ +/* { dg-final { scan-assembler "\[ \t\]and " } } */ +/* { dg-final { scan-assembler "\[ \t\]or " } } */ +/* { dg-final { scan-assembler "\[ \t\]xor " } } */ +/* { dg-final { scan-assembler "\[ \t\]nor " } } */ +/* { dg-final { scan-assembler "\[ \t\]andc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxland " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxleqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlorc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnand " } } */ + +/* On power7, for 128-bit types, ORC/ANDC/EQV might not show up, since the + vector unit doesn't support these, so the appropriate combine patterns may + not be generated. */ + +#ifndef TYPE +#ifdef _ARCH_PPC64 +#define TYPE __int128_t +#else +typedef int v4si __attribute__ ((vector_size (16))); +#define TYPE v4si +#endif +#endif + +#include "bool3.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-p8.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-p8.c new file mode 100644 index 000000000..e1b2dfa7e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3-p8.c @@ -0,0 +1,36 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-O2 -mcpu=power8" } */ +/* { dg-final { scan-assembler "\[ \t\]and " } } */ +/* { dg-final { scan-assembler "\[ \t\]or " } } */ +/* { dg-final { scan-assembler "\[ \t\]xor " } } */ +/* { dg-final { scan-assembler "\[ \t\]nor " } } */ +/* { dg-final { scan-assembler "\[ \t\]andc " } } */ +/* { dg-final { scan-assembler "\[ \t\]eqv " } } */ +/* { dg-final { scan-assembler "\[ \t\]orc " } } */ +/* { dg-final { scan-assembler "\[ \t\]nand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vand " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]vnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxland " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlxor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnor " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlandc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxleqv " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlorc " } } */ +/* { dg-final { scan-assembler-not "\[ \t\]xxlnand " } } */ + +#ifndef TYPE +#ifdef _ARCH_PPC64 +#define TYPE __int128_t +#else +typedef int v4si __attribute__ ((vector_size (16))); +#define TYPE v4si +#endif +#endif + +#include "bool3.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3.h b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3.h new file mode 100644 index 000000000..7b99a4a61 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/bool3.h @@ -0,0 +1,186 @@ +/* Test forcing 128-bit logical types into GPR registers. */ + +#if defined(NO_ASM) +#define FORCE_REG1(X) +#define FORCE_REG2(X,Y) + +#else +#if defined(USE_ALTIVEC) +#define REG_CLASS "+v" +#define PRINT_REG1 "# altivec reg %0" +#define PRINT_REG2 "# altivec reg %0, %1" + +#elif defined(USE_FPR) +#define REG_CLASS "+d" +#define PRINT_REG1 "# fpr reg %0" +#define PRINT_REG2 "# fpr reg %0, %1" + +#elif defined(USE_VSX) +#define REG_CLASS "+wa" +#define PRINT_REG1 "# vsx reg %x0" +#define PRINT_REG2 "# vsx reg %x0, %x1" + +#else +#define REG_CLASS "+r" +#define PRINT_REG1 "# gpr reg %0" +#define PRINT_REG2 "# gpr reg %0, %1" +#endif + +#define FORCE_REG1(X) __asm__ (PRINT_REG1 : REG_CLASS (X)) +#define FORCE_REG2(X,Y) __asm__ (PRINT_REG2 : REG_CLASS (X), REG_CLASS (Y)) +#endif + +void ptr1 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = a & b; /* AND */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr2 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = a | b; /* OR */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr3 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = a ^ b; /* XOR */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr4 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b; + + FORCE_REG1 (a); + b = ~a; /* NOR */ + FORCE_REG1 (b); + p[0] = b; +} + +void ptr5 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = ~(a & b); /* NAND */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr6 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = ~(a | b); /* AND */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr7 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = ~(a ^ b); /* EQV */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr8 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = (~a) & b; /* ANDC */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr9 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = (~a) | b; /* ORC */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr10 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = (~a) ^ b; /* EQV */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr11 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = a & (~b); /* ANDC */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr12 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = a | (~b); /* ORC */ + FORCE_REG1 (c); + p[0] = c; +} + +void ptr13 (TYPE *p) +{ + TYPE a = p[1]; + TYPE b = p[2]; + TYPE c; + + FORCE_REG2 (a, b); + c = a ^ (~b); /* AND */ + FORCE_REG1 (c); + p[0] = c; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/crypto-builtin-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/crypto-builtin-1.c new file mode 100644 index 000000000..87291954e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/crypto-builtin-1.c @@ -0,0 +1,130 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model -fno-unroll-loops -fno-unroll-all-loops" } */ + +typedef vector unsigned long long crypto_t; +typedef vector unsigned long long v2di_t; +typedef vector unsigned int v4si_t; +typedef vector unsigned short v8hi_t; +typedef vector unsigned char v16qi_t; + +crypto_t crpyto1 (crypto_t a) +{ + return __builtin_crypto_vsbox (a); +} + +crypto_t crypto2 (crypto_t a, crypto_t b) +{ + return __builtin_crypto_vcipher (a, b); +} + +crypto_t crypto3 (crypto_t a, crypto_t b) +{ + return __builtin_crypto_vcipherlast (a, b); +} + +crypto_t crypto4 (crypto_t a, crypto_t b) +{ + return __builtin_crypto_vncipher (a, b); +} + +crypto_t crypto5 (crypto_t a, crypto_t b) +{ + return __builtin_crypto_vncipherlast (a, b); +} + +v16qi_t crypto6a (v16qi_t a, v16qi_t b, v16qi_t c) +{ + return __builtin_crypto_vpermxor (a, b, c); +} + +v8hi_t crypto6b (v8hi_t a, v8hi_t b, v8hi_t c) +{ + return __builtin_crypto_vpermxor (a, b, c); +} + +v4si_t crypto6c (v4si_t a, v4si_t b, v4si_t c) +{ + return __builtin_crypto_vpermxor (a, b, c); +} + +v2di_t crypto6d (v2di_t a, v2di_t b, v2di_t c) +{ + return __builtin_crypto_vpermxor (a, b, c); +} + +v16qi_t crypto7a (v16qi_t a, v16qi_t b) +{ + return __builtin_crypto_vpmsumb (a, b); +} + +v16qi_t crypto7b (v16qi_t a, v16qi_t b) +{ + return __builtin_crypto_vpmsum (a, b); +} + +v8hi_t crypto7c (v8hi_t a, v8hi_t b) +{ + return __builtin_crypto_vpmsumh (a, b); +} + +v8hi_t crypto7d (v8hi_t a, v8hi_t b) +{ + return __builtin_crypto_vpmsum (a, b); +} + +v4si_t crypto7e (v4si_t a, v4si_t b) +{ + return __builtin_crypto_vpmsumw (a, b); +} + +v4si_t crypto7f (v4si_t a, v4si_t b) +{ + return __builtin_crypto_vpmsum (a, b); +} + +v2di_t crypto7g (v2di_t a, v2di_t b) +{ + return __builtin_crypto_vpmsumd (a, b); +} + +v2di_t crypto7h (v2di_t a, v2di_t b) +{ + return __builtin_crypto_vpmsum (a, b); +} + +v2di_t crypto8a (v2di_t a) +{ + return __builtin_crypto_vshasigmad (a, 0, 8); +} + +v2di_t crypto8b (v2di_t a) +{ + return __builtin_crypto_vshasigma (a, 0, 8); +} + +v4si_t crypto8c (v4si_t a) +{ + return __builtin_crypto_vshasigmaw (a, 1, 15); +} + +v4si_t crypto8d (v4si_t a) +{ + return __builtin_crypto_vshasigma (a, 1, 15); +} + +/* Note space is used after the instruction so that vcipherlast does not match + vcipher. */ +/* { dg-final { scan-assembler-times "vcipher " 1 } } */ +/* { dg-final { scan-assembler-times "vcipherlast " 1 } } */ +/* { dg-final { scan-assembler-times "vncipher " 1 } } */ +/* { dg-final { scan-assembler-times "vncipherlast " 1 } } */ +/* { dg-final { scan-assembler-times "vpermxor " 4 } } */ +/* { dg-final { scan-assembler-times "vpmsumb " 2 } } */ +/* { dg-final { scan-assembler-times "vpmsumd " 2 } } */ +/* { dg-final { scan-assembler-times "vpmsumh " 2 } } */ +/* { dg-final { scan-assembler-times "vpmsumw " 2 } } */ +/* { dg-final { scan-assembler-times "vsbox " 1 } } */ +/* { dg-final { scan-assembler-times "vshasigmad " 2 } } */ +/* { dg-final { scan-assembler-times "vshasigmaw " 2 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/darwin-longlong.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/darwin-longlong.c index 0692b3d80..14b56d082 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/darwin-longlong.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/darwin-longlong.c @@ -11,7 +11,11 @@ int msw(long long in) int i[2]; } ud; ud.ll = in; +#ifdef __LITTLE_ENDIAN__ + return ud.i[1]; +#else return ud.i[0]; +#endif } int main() diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-builtin-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-builtin-1.c new file mode 100644 index 000000000..614f27264 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-builtin-1.c @@ -0,0 +1,88 @@ +/* { dg-do compile { target { powerpc*-*-linux* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mcpu=power7 -O2" } */ +/* { dg-final { scan-assembler-times "ddedpd " 4 } } */ +/* { dg-final { scan-assembler-times "denbcd " 2 } } */ +/* { dg-final { scan-assembler-times "dxex " 1 } } */ +/* { dg-final { scan-assembler-times "diex " 1 } } */ +/* { dg-final { scan-assembler-times "dscli " 2 } } */ +/* { dg-final { scan-assembler-times "dscri " 2 } } */ +/* { dg-final { scan-assembler-not "bl __builtin" } } */ +/* { dg-final { scan-assembler-not "dctqpq" } } */ +/* { dg-final { scan-assembler-not "drdpq" } } */ +/* { dg-final { scan-assembler-not "stfd" } } */ +/* { dg-final { scan-assembler-not "lfd" } } */ + +_Decimal64 +do_dedpd_0 (_Decimal64 a) +{ + return __builtin_ddedpd (0, a); +} + +_Decimal64 +do_dedpd_1 (_Decimal64 a) +{ + return __builtin_ddedpd (1, a); +} + +_Decimal64 +do_dedpd_2 (_Decimal64 a) +{ + return __builtin_ddedpd (2, a); +} + +_Decimal64 +do_dedpd_3 (_Decimal64 a) +{ + return __builtin_ddedpd (3, a); +} + +_Decimal64 +do_enbcd_0 (_Decimal64 a) +{ + return __builtin_denbcd (0, a); +} + +_Decimal64 +do_enbcd_1 (_Decimal64 a) +{ + return __builtin_denbcd (1, a); +} + +_Decimal64 +do_xex (_Decimal64 a) +{ + return __builtin_dxex (a); +} + +_Decimal64 +do_iex (_Decimal64 a, _Decimal64 b) +{ + return __builtin_diex (a, b); +} + +_Decimal64 +do_scli_1 (_Decimal64 a) +{ + return __builtin_dscli (a, 1); +} + +_Decimal64 +do_scli_10 (_Decimal64 a) +{ + return __builtin_dscli (a, 10); +} + +_Decimal64 +do_scri_1 (_Decimal64 a) +{ + return __builtin_dscri (a, 1); +} + +_Decimal64 +do_scri_10 (_Decimal64 a) +{ + return __builtin_dscri (a, 10); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-builtin-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-builtin-2.c new file mode 100644 index 000000000..189bc9ad6 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-builtin-2.c @@ -0,0 +1,88 @@ +/* { dg-do compile { target { powerpc*-*-linux* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mcpu=power7 -O2" } */ +/* { dg-final { scan-assembler-times "ddedpdq " 4 } } */ +/* { dg-final { scan-assembler-times "denbcdq " 2 } } */ +/* { dg-final { scan-assembler-times "dxexq " 1 } } */ +/* { dg-final { scan-assembler-times "diexq " 1 } } */ +/* { dg-final { scan-assembler-times "dscliq " 2 } } */ +/* { dg-final { scan-assembler-times "dscriq " 2 } } */ +/* { dg-final { scan-assembler-not "bl __builtin" } } */ +/* { dg-final { scan-assembler-not "dctqpq" } } */ +/* { dg-final { scan-assembler-not "drdpq" } } */ +/* { dg-final { scan-assembler-not "stfd" } } */ +/* { dg-final { scan-assembler-not "lfd" } } */ + +_Decimal128 +do_dedpdq_0 (_Decimal128 a) +{ + return __builtin_ddedpdq (0, a); +} + +_Decimal128 +do_dedpdq_1 (_Decimal128 a) +{ + return __builtin_ddedpdq (1, a); +} + +_Decimal128 +do_dedpdq_2 (_Decimal128 a) +{ + return __builtin_ddedpdq (2, a); +} + +_Decimal128 +do_dedpdq_3 (_Decimal128 a) +{ + return __builtin_ddedpdq (3, a); +} + +_Decimal128 +do_enbcdq_0 (_Decimal128 a) +{ + return __builtin_denbcdq (0, a); +} + +_Decimal128 +do_enbcdq_1 (_Decimal128 a) +{ + return __builtin_denbcdq (1, a); +} + +_Decimal128 +do_xexq (_Decimal128 a) +{ + return __builtin_dxexq (a); +} + +_Decimal128 +do_iexq (_Decimal128 a, _Decimal128 b) +{ + return __builtin_diexq (a, b); +} + +_Decimal128 +do_scliq_1 (_Decimal128 a) +{ + return __builtin_dscliq (a, 1); +} + +_Decimal128 +do_scliq_10 (_Decimal128 a) +{ + return __builtin_dscliq (a, 10); +} + +_Decimal128 +do_scriq_1 (_Decimal128 a) +{ + return __builtin_dscriq (a, 1); +} + +_Decimal128 +do_scriq_10 (_Decimal128 a) +{ + return __builtin_dscriq (a, 10); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-dd-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-dd-2.c new file mode 100644 index 000000000..fcb72bdff --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-dd-2.c @@ -0,0 +1,26 @@ +/* Test generation of DFP instructions for POWER6. */ +/* { dg-do compile { target { powerpc*-*-linux* && powerpc_fprs } } } */ +/* { dg-options "-std=gnu99 -O1 -mcpu=power6" } */ + +/* { dg-final { scan-assembler-times "fneg" 1 } } */ +/* { dg-final { scan-assembler-times "fabs" 1 } } */ +/* { dg-final { scan-assembler-times "fnabs" 1 } } */ +/* { dg-final { scan-assembler-times "fmr" 0 } } */ + +_Decimal64 +func1 (_Decimal64 a, _Decimal64 b) +{ + return -b; +} + +_Decimal64 +func2 (_Decimal64 a, _Decimal64 b) +{ + return __builtin_fabsd64 (b); +} + +_Decimal64 +func3 (_Decimal64 a, _Decimal64 b) +{ + return - __builtin_fabsd64 (b); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-td-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-td-2.c new file mode 100644 index 000000000..a078cc469 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-td-2.c @@ -0,0 +1,29 @@ +/* Test generation of DFP instructions for POWER6. */ +/* { dg-do compile { target { powerpc*-*-linux* && powerpc_fprs } } } */ +/* { dg-options "-std=gnu99 -O1 -mcpu=power6" } */ + +/* { dg-final { scan-assembler-times "fneg" 1 } } */ +/* { dg-final { scan-assembler-times "fabs" 1 } } */ +/* { dg-final { scan-assembler-times "fnabs" 1 } } */ +/* { dg-final { scan-assembler-times "fmr" 0 } } */ + +/* These tests verify we only generate fneg, fabs and fnabs + instructions and no fmr's since these are done in place. */ + +_Decimal128 +func1 (_Decimal128 a) +{ + return -a; +} + +_Decimal128 +func2 (_Decimal128 a) +{ + return __builtin_fabsd128 (a); +} + +_Decimal128 +func3 (_Decimal128 a) +{ + return - __builtin_fabsd128 (a); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-td-3.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-td-3.c new file mode 100644 index 000000000..e825e5cad --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/dfp-td-3.c @@ -0,0 +1,29 @@ +/* Test generation of DFP instructions for POWER6. */ +/* { dg-do compile { target { powerpc*-*-linux* && powerpc_fprs } } } */ +/* { dg-options "-std=gnu99 -O1 -mcpu=power6" } */ + +/* { dg-final { scan-assembler-times "fneg" 1 } } */ +/* { dg-final { scan-assembler-times "fabs" 1 } } */ +/* { dg-final { scan-assembler-times "fnabs" 1 } } */ +/* { dg-final { scan-assembler-times "fmr" 3 } } */ + +/* These tests verify we generate fneg, fabs and fnabs and + associated fmr's since these are not done in place. */ + +_Decimal128 +func1 (_Decimal128 a, _Decimal128 b) +{ + return -b; +} + +_Decimal128 +func2 (_Decimal128 a, _Decimal128 b) +{ + return __builtin_fabsd128 (b); +} + +_Decimal128 +func3 (_Decimal128 a, _Decimal128 b) +{ + return - __builtin_fabsd128 (b); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-double1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-double1.c new file mode 100644 index 000000000..2569ac843 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-double1.c @@ -0,0 +1,16 @@ +/* { dg-do compile { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler "mtvsrd" } } */ +/* { dg-final { scan-assembler "mfvsrd" } } */ + +/* Check code generation for direct move for double types. */ + +#define TYPE double +#define IS_FLOAT 1 +#define NO_ALTIVEC 1 +#define VSX_REG_ATTR "ws" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-double2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-double2.c new file mode 100644 index 000000000..c8702204b --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-double2.c @@ -0,0 +1,15 @@ +/* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target p8vector_hw } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +/* Check whether we get the right bits for direct move at runtime. */ + +#define TYPE double +#define IS_FLOAT 1 +#define NO_ALTIVEC 1 +#define DO_MAIN +#define VSX_REG_ATTR "ws" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-float1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-float1.c new file mode 100644 index 000000000..524c0eead --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-float1.c @@ -0,0 +1,18 @@ +/* { dg-do compile { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler "mtvsrd" } } */ +/* { dg-final { scan-assembler "mfvsrd" } } */ +/* { dg-final { scan-assembler "xscvdpspn" } } */ +/* { dg-final { scan-assembler "xscvspdpn" } } */ + +/* Check code generation for direct move for float types. */ + +#define TYPE float +#define IS_FLOAT 1 +#define NO_ALTIVEC 1 +#define VSX_REG_ATTR "ww" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-float2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-float2.c new file mode 100644 index 000000000..352e76166 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-float2.c @@ -0,0 +1,15 @@ +/* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target p8vector_hw } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +/* Check whether we get the right bits for direct move at runtime. */ + +#define TYPE float +#define IS_FLOAT 1 +#define NO_ALTIVEC 1 +#define DO_MAIN +#define VSX_REG_ATTR "ww" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-long1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-long1.c new file mode 100644 index 000000000..0a78f9cb2 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-long1.c @@ -0,0 +1,16 @@ +/* { dg-do compile { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler "mtvsrd" } } */ +/* { dg-final { scan-assembler "mfvsrd" } } */ + +/* Check code generation for direct move for long types. */ + +#define TYPE long +#define IS_INT 1 +#define NO_ALTIVEC 1 +#define VSX_REG_ATTR "d" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-long2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-long2.c new file mode 100644 index 000000000..cee9e0e0f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-long2.c @@ -0,0 +1,15 @@ +/* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target p8vector_hw } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +/* Check whether we get the right bits for direct move at runtime. */ + +#define TYPE long +#define IS_INT 1 +#define NO_ALTIVEC 1 +#define DO_MAIN +#define VSX_REG_ATTR "d" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-vint1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-vint1.c new file mode 100644 index 000000000..3067b9a8e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-vint1.c @@ -0,0 +1,14 @@ +/* { dg-do compile { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ +/* { dg-final { scan-assembler "mtvsrd" } } */ +/* { dg-final { scan-assembler "mfvsrd" } } */ + +/* Check code generation for direct move for vector types. */ + +#define TYPE vector int +#define VSX_REG_ATTR "wa" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-vint2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-vint2.c new file mode 100644 index 000000000..0d8264faf --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move-vint2.c @@ -0,0 +1,13 @@ +/* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target p8vector_hw } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +/* Check whether we get the right bits for direct move at runtime. */ + +#define TYPE vector int +#define DO_MAIN +#define VSX_REG_ATTR "wa" + +#include "direct-move.h" diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move.h b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move.h new file mode 100644 index 000000000..6a5b7ba18 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/direct-move.h @@ -0,0 +1,188 @@ +/* Test functions for direct move support. */ + +#include <math.h> +extern void abort (void); + +#ifndef VSX_REG_ATTR +#define VSX_REG_ATTR "wa" +#endif + +void __attribute__((__noinline__)) +copy (TYPE *a, TYPE *b) +{ + *b = *a; +} + +#ifndef NO_GPR +void __attribute__((__noinline__)) +load_gpr (TYPE *a, TYPE *b) +{ + TYPE c = *a; + __asm__ ("# gpr, reg = %0" : "+b" (c)); + *b = c; +} +#endif + +#ifndef NO_FPR +void __attribute__((__noinline__)) +load_fpr (TYPE *a, TYPE *b) +{ + TYPE c = *a; + __asm__ ("# fpr, reg = %0" : "+d" (c)); + *b = c; +} +#endif + +#ifndef NO_ALTIVEC +void __attribute__((__noinline__)) +load_altivec (TYPE *a, TYPE *b) +{ + TYPE c = *a; + __asm__ ("# altivec, reg = %0" : "+v" (c)); + *b = c; +} +#endif + +#ifndef NO_VSX +void __attribute__((__noinline__)) +load_vsx (TYPE *a, TYPE *b) +{ + TYPE c = *a; + __asm__ ("# vsx, reg = %x0" : "+" VSX_REG_ATTR (c)); + *b = c; +} +#endif + +#ifndef NO_GPR_TO_VSX +void __attribute__((__noinline__)) +load_gpr_to_vsx (TYPE *a, TYPE *b) +{ + TYPE c = *a; + TYPE d; + __asm__ ("# gpr, reg = %0" : "+b" (c)); + d = c; + __asm__ ("# vsx, reg = %x0" : "+" VSX_REG_ATTR (d)); + *b = d; +} +#endif + +#ifndef NO_VSX_TO_GPR +void __attribute__((__noinline__)) +load_vsx_to_gpr (TYPE *a, TYPE *b) +{ + TYPE c = *a; + TYPE d; + __asm__ ("# vsx, reg = %x0" : "+" VSX_REG_ATTR (c)); + d = c; + __asm__ ("# gpr, reg = %0" : "+b" (d)); + *b = d; +} +#endif + +#ifdef DO_MAIN +typedef void (fn_type (TYPE *, TYPE *)); + +struct test_struct { + fn_type *func; + const char *name; +}; + +const struct test_struct test_functions[] = { + { copy, "copy" }, +#ifndef NO_GPR + { load_gpr, "load_gpr" }, +#endif +#ifndef NO_FPR + { load_fpr, "load_fpr" }, +#endif +#ifndef NO_ALTIVEC + { load_altivec, "load_altivec" }, +#endif +#ifndef NO_VSX + { load_vsx, "load_vsx" }, +#endif +#ifndef NO_GPR_TO_VSX + { load_gpr_to_vsx, "load_gpr_to_vsx" }, +#endif +#ifndef NO_VSX_TO_GPR + { load_vsx_to_gpr, "load_vsx_to_gpr" }, +#endif +}; + +/* Test a given value for each of the functions. */ +void __attribute__((__noinline__)) +test_value (TYPE a) +{ + long i; + + for (i = 0; i < sizeof (test_functions) / sizeof (test_functions[0]); i++) + { + TYPE b; + + test_functions[i].func (&a, &b); + if (memcmp ((void *)&a, (void *)&b, sizeof (TYPE)) != 0) + abort (); + } +} + +/* Main program. */ +int +main (void) +{ + long i,j; + union { + TYPE value; + unsigned char bytes[sizeof (TYPE)]; + } u; + +#if IS_INT + TYPE value = (TYPE)-5; + for (i = 0; i < 12; i++) + { + test_value (value); + value++; + } + + for (i = 0; i < 8*sizeof (TYPE); i++) + test_value (((TYPE)1) << i); + +#elif IS_UNS + TYPE value = (TYPE)0; + for (i = 0; i < 10; i++) + { + test_value (value); + test_value (~ value); + value++; + } + + for (i = 0; i < 8*sizeof (TYPE); i++) + test_value (((TYPE)1) << i); + +#elif IS_FLOAT + TYPE value = (TYPE)-5; + for (i = 0; i < 12; i++) + { + test_value (value); + value++; + } + + test_value ((TYPE)3.1415926535); + test_value ((TYPE)1.23456); + test_value ((TYPE)(-0.0)); + test_value ((TYPE)NAN); + test_value ((TYPE)+INFINITY); + test_value ((TYPE)-INFINITY); +#else + + for (j = 0; j < 10; j++) + { + for (i = 0; i < sizeof (TYPE); i++) + u.bytes[i] = (unsigned char) (random () >> 4); + + test_value (u.value); + } +#endif + + return 0; +} +#endif diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/extend-divide-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/extend-divide-1.c new file mode 100644 index 000000000..5f948b721 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/extend-divide-1.c @@ -0,0 +1,34 @@ +/* { dg-do compile { target { powerpc*-*-linux* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mcpu=power7 -O2" } */ +/* { dg-final { scan-assembler-times "divwe " 1 } } */ +/* { dg-final { scan-assembler-times "divweo " 1 } } */ +/* { dg-final { scan-assembler-times "divweu " 1 } } */ +/* { dg-final { scan-assembler-times "divweuo " 1 } } */ +/* { dg-final { scan-assembler-not "bl __builtin" } } */ + +int +div_we (int a, int b) +{ + return __builtin_divwe (a, b); +} + +int +div_weo (int a, int b) +{ + return __builtin_divweo (a, b); +} + +unsigned int +div_weu (unsigned int a, unsigned int b) +{ + return __builtin_divweu (a, b); +} + +unsigned int +div_weuo (unsigned int a, unsigned int b) +{ + return __builtin_divweuo (a, b); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/extend-divide-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/extend-divide-2.c new file mode 100644 index 000000000..8ee6c8cf7 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/extend-divide-2.c @@ -0,0 +1,34 @@ +/* { dg-do compile { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mcpu=power7 -O2" } */ +/* { dg-final { scan-assembler-times "divde " 1 } } */ +/* { dg-final { scan-assembler-times "divdeo " 1 } } */ +/* { dg-final { scan-assembler-times "divdeu " 1 } } */ +/* { dg-final { scan-assembler-times "divdeuo " 1 } } */ +/* { dg-final { scan-assembler-not "bl __builtin" } } */ + +long +div_de (long a, long b) +{ + return __builtin_divde (a, b); +} + +long +div_deo (long a, long b) +{ + return __builtin_divdeo (a, b); +} + +unsigned long +div_deu (unsigned long a, unsigned long b) +{ + return __builtin_divdeu (a, b); +} + +unsigned long +div_deuo (unsigned long a, unsigned long b) +{ + return __builtin_divdeuo (a, b); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/fusion.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/fusion.c new file mode 100644 index 000000000..60e635972 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/fusion.c @@ -0,0 +1,24 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*le-*-* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power7 -mtune=power8 -O3" } */ + +#define LARGE 0x12345 + +int fusion_uchar (unsigned char *p){ return p[LARGE]; } +int fusion_schar (signed char *p){ return p[LARGE]; } +int fusion_ushort (unsigned short *p){ return p[LARGE]; } +int fusion_short (short *p){ return p[LARGE]; } +int fusion_int (int *p){ return p[LARGE]; } +unsigned fusion_uns (unsigned *p){ return p[LARGE]; } + +vector double fusion_vector (vector double *p) { return p[2]; } + +/* { dg-final { scan-assembler-times "gpr load fusion" 6 } } */ +/* { dg-final { scan-assembler-times "vector load fusion" 1 } } */ +/* { dg-final { scan-assembler-times "lbz" 2 } } */ +/* { dg-final { scan-assembler-times "extsb" 1 } } */ +/* { dg-final { scan-assembler-times "lhz" 2 } } */ +/* { dg-final { scan-assembler-times "extsh" 1 } } */ +/* { dg-final { scan-assembler-times "lwz" 2 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/htm-builtin-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/htm-builtin-1.c new file mode 100644 index 000000000..e58816a7f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/htm-builtin-1.c @@ -0,0 +1,51 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_htm_ok } */ +/* { dg-options "-O2 -mhtm" } */ + +/* { dg-final { scan-assembler-times "tbegin\\." 1 } } */ +/* { dg-final { scan-assembler-times "tend\\." 2 } } */ +/* { dg-final { scan-assembler-times "tabort\\." 2 } } */ +/* { dg-final { scan-assembler-times "tabortdc\\." 1 } } */ +/* { dg-final { scan-assembler-times "tabortdci\\." 1 } } */ +/* { dg-final { scan-assembler-times "tabortwc\\." 1 } } */ +/* { dg-final { scan-assembler-times "tabortwci\\." 2 } } */ +/* { dg-final { scan-assembler-times "tcheck\\." 1 } } */ +/* { dg-final { scan-assembler-times "trechkpt\\." 1 } } */ +/* { dg-final { scan-assembler-times "treclaim\\." 1 } } */ +/* { dg-final { scan-assembler-times "tsr\\." 3 } } */ +/* { dg-final { scan-assembler-times "mfspr" 4 } } */ +/* { dg-final { scan-assembler-times "mtspr" 4 } } */ + +void use_builtins (long *p, char code, long *a, long *b) +{ + p[0] = __builtin_tbegin (0); + p[1] = __builtin_tend (0); + p[2] = __builtin_tendall (); + p[3] = __builtin_tabort (0); + p[4] = __builtin_tabort (code); + + p[5] = __builtin_tabortdc (0xf, a[5], b[5]); + p[6] = __builtin_tabortdci (0xf, a[6], 13); + p[7] = __builtin_tabortwc (0xf, a[7], b[7]); + p[8] = __builtin_tabortwci (0xf, a[8], 13); + + p[9] = __builtin_tcheck (5); + p[10] = __builtin_trechkpt (); + p[11] = __builtin_treclaim (0); + p[12] = __builtin_tresume (); + p[13] = __builtin_tsuspend (); + p[14] = __builtin_tsr (0); + p[15] = __builtin_ttest (); /* This expands to a tabortwci. */ + + + p[16] = __builtin_get_texasr (); + p[17] = __builtin_get_texasru (); + p[18] = __builtin_get_tfhar (); + p[19] = __builtin_get_tfiar (); + + __builtin_set_texasr (a[20]); + __builtin_set_texasru (a[21]); + __builtin_set_tfhar (a[22]); + __builtin_set_tfiar (a[23]); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/htm-xl-intrin-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/htm-xl-intrin-1.c new file mode 100644 index 000000000..5e92814b7 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/htm-xl-intrin-1.c @@ -0,0 +1,32 @@ +/* This checks the availability of the XL compiler intrinsics for + transactional execution with the expected prototypes. */ + +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_htm_ok } */ +/* { dg-options "-O2 -mhtm" } */ + +#include <htmxlintrin.h> + +void +foo (void *TM_buff, long *result, unsigned char *code) +{ + *result++ = __TM_simple_begin (); + *result++ = __TM_begin (TM_buff); + *result++ = __TM_end (); + __TM_abort (); + __TM_named_abort (*code); + __TM_resume (); + __TM_suspend (); + *result++ = __TM_is_user_abort (TM_buff); + *result++ = __TM_is_named_user_abort (TM_buff, code); + *result++ = __TM_is_illegal (TM_buff); + *result++ = __TM_is_footprint_exceeded (TM_buff); + *result++ = __TM_nesting_depth (TM_buff); + *result++ = __TM_is_nested_too_deep (TM_buff); + *result++ = __TM_is_conflict (TM_buff); + *result++ = __TM_is_failure_persistent (TM_buff); + *result++ = __TM_failure_address (TM_buff); + *result++ = __TM_failure_code (TM_buff); +} + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/mmfpgpr.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/mmfpgpr.c new file mode 100644 index 000000000..7f2d3d3ef --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/mmfpgpr.c @@ -0,0 +1,22 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power6x -mmfpgpr" } */ +/* { dg-final { scan-assembler "mffgpr" } } */ +/* { dg-final { scan-assembler "mftgpr" } } */ + +/* Test that we generate the instructions to move between the GPR and FPR + registers under power6x. */ + +extern long return_long (void); +extern double return_double (void); + +double return_double2 (void) +{ + return (double) return_long (); +} + +long return_long2 (void) +{ + return (long) return_double (); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-1.c new file mode 100644 index 000000000..6fd3acc2a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-1.c @@ -0,0 +1,65 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model -fno-unroll-loops -fno-unroll-all-loops" } */ + +#ifndef TYPE +#define TYPE long long +#endif + +#ifndef SIGN_TYPE +#define SIGN_TYPE signed TYPE +#endif + +#ifndef UNS_TYPE +#define UNS_TYPE unsigned TYPE +#endif + +typedef vector SIGN_TYPE v_sign; +typedef vector UNS_TYPE v_uns; + +v_sign sign_add (v_sign a, v_sign b) +{ + return a + b; +} + +v_sign sign_sub (v_sign a, v_sign b) +{ + return a - b; +} + +v_sign sign_shift_left (v_sign a, v_sign b) +{ + return a << b; +} + +v_sign sign_shift_right (v_sign a, v_sign b) +{ + return a >> b; +} + +v_uns uns_add (v_uns a, v_uns b) +{ + return a + b; +} + +v_uns uns_sub (v_uns a, v_uns b) +{ + return a - b; +} + +v_uns uns_shift_left (v_uns a, v_uns b) +{ + return a << b; +} + +v_uns uns_shift_right (v_uns a, v_uns b) +{ + return a >> b; +} + +/* { dg-final { scan-assembler-times "vaddudm" 2 } } */ +/* { dg-final { scan-assembler-times "vsubudm" 2 } } */ +/* { dg-final { scan-assembler-times "vsld" 2 } } */ +/* { dg-final { scan-assembler-times "vsrad" 1 } } */ +/* { dg-final { scan-assembler-times "vsrd" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-2.c new file mode 100644 index 000000000..412040bfa --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-2.c @@ -0,0 +1,204 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model -fno-unroll-loops -fno-unroll-all-loops" } */ + +#include <altivec.h> + +typedef vector long long v_sign; +typedef vector unsigned long long v_uns; +typedef vector bool long long v_bool; + +v_sign sign_add_1 (v_sign a, v_sign b) +{ + return __builtin_altivec_vaddudm (a, b); +} + +v_sign sign_add_2 (v_sign a, v_sign b) +{ + return vec_add (a, b); +} + +v_sign sign_add_3 (v_sign a, v_sign b) +{ + return vec_vaddudm (a, b); +} + +v_sign sign_sub_1 (v_sign a, v_sign b) +{ + return __builtin_altivec_vsubudm (a, b); +} + +v_sign sign_sub_2 (v_sign a, v_sign b) +{ + return vec_sub (a, b); +} + + +v_sign sign_sub_3 (v_sign a, v_sign b) +{ + return vec_vsubudm (a, b); +} + +v_sign sign_min_1 (v_sign a, v_sign b) +{ + return __builtin_altivec_vminsd (a, b); +} + +v_sign sign_min_2 (v_sign a, v_sign b) +{ + return vec_min (a, b); +} + +v_sign sign_min_3 (v_sign a, v_sign b) +{ + return vec_vminsd (a, b); +} + +v_sign sign_max_1 (v_sign a, v_sign b) +{ + return __builtin_altivec_vmaxsd (a, b); +} + +v_sign sign_max_2 (v_sign a, v_sign b) +{ + return vec_max (a, b); +} + +v_sign sign_max_3 (v_sign a, v_sign b) +{ + return vec_vmaxsd (a, b); +} + +v_sign sign_abs (v_sign a) +{ + return vec_abs (a); /* xor, vsubudm, vmaxsd. */ +} + +v_bool sign_eq (v_sign a, v_sign b) +{ + return vec_cmpeq (a, b); +} + +v_bool sign_lt (v_sign a, v_sign b) +{ + return vec_cmplt (a, b); +} + +v_uns uns_add_2 (v_uns a, v_uns b) +{ + return vec_add (a, b); +} + +v_uns uns_add_3 (v_uns a, v_uns b) +{ + return vec_vaddudm (a, b); +} + +v_uns uns_sub_2 (v_uns a, v_uns b) +{ + return vec_sub (a, b); +} + +v_uns uns_sub_3 (v_uns a, v_uns b) +{ + return vec_vsubudm (a, b); +} + +v_uns uns_min_2 (v_uns a, v_uns b) +{ + return vec_min (a, b); +} + +v_uns uns_min_3 (v_uns a, v_uns b) +{ + return vec_vminud (a, b); +} + +v_uns uns_max_2 (v_uns a, v_uns b) +{ + return vec_max (a, b); +} + +v_uns uns_max_3 (v_uns a, v_uns b) +{ + return vec_vmaxud (a, b); +} + +v_bool uns_eq (v_uns a, v_uns b) +{ + return vec_cmpeq (a, b); +} + +v_bool uns_lt (v_uns a, v_uns b) +{ + return vec_cmplt (a, b); +} + +v_sign sign_rl_1 (v_sign a, v_sign b) +{ + return __builtin_altivec_vrld (a, b); +} + +v_sign sign_rl_2 (v_sign a, v_uns b) +{ + return vec_rl (a, b); +} + +v_uns uns_rl_2 (v_uns a, v_uns b) +{ + return vec_rl (a, b); +} + +v_sign sign_sl_1 (v_sign a, v_sign b) +{ + return __builtin_altivec_vsld (a, b); +} + +v_sign sign_sl_2 (v_sign a, v_uns b) +{ + return vec_sl (a, b); +} + +v_sign sign_sl_3 (v_sign a, v_uns b) +{ + return vec_vsld (a, b); +} + +v_uns uns_sl_2 (v_uns a, v_uns b) +{ + return vec_sl (a, b); +} + +v_uns uns_sl_3 (v_uns a, v_uns b) +{ + return vec_vsld (a, b); +} + +v_sign sign_sra_1 (v_sign a, v_sign b) +{ + return __builtin_altivec_vsrad (a, b); +} + +v_sign sign_sra_2 (v_sign a, v_uns b) +{ + return vec_sra (a, b); +} + +v_sign sign_sra_3 (v_sign a, v_uns b) +{ + return vec_vsrad (a, b); +} + +/* { dg-final { scan-assembler-times "vaddudm" 5 } } */ +/* { dg-final { scan-assembler-times "vsubudm" 6 } } */ +/* { dg-final { scan-assembler-times "vmaxsd" 4 } } */ +/* { dg-final { scan-assembler-times "vminsd" 3 } } */ +/* { dg-final { scan-assembler-times "vmaxud" 2 } } */ +/* { dg-final { scan-assembler-times "vminud" 2 } } */ +/* { dg-final { scan-assembler-times "vcmpequd" 2 } } */ +/* { dg-final { scan-assembler-times "vcmpgtsd" 1 } } */ +/* { dg-final { scan-assembler-times "vcmpgtud" 1 } } */ +/* { dg-final { scan-assembler-times "vrld" 3 } } */ +/* { dg-final { scan-assembler-times "vsld" 5 } } */ +/* { dg-final { scan-assembler-times "vsrad" 3 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-3.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-3.c new file mode 100644 index 000000000..b3f725f2d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-3.c @@ -0,0 +1,104 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O3 -ftree-vectorize -fvect-cost-model" } */ + +#include <altivec.h> + +typedef vector long long vll_sign; +typedef vector unsigned long long vll_uns; +typedef vector bool long long vll_bool; + +typedef vector int vi_sign; +typedef vector unsigned int vi_uns; +typedef vector bool int vi_bool; + +typedef vector short vs_sign; +typedef vector unsigned short vs_uns; +typedef vector bool short vs_bool; + +typedef vector signed char vc_sign; +typedef vector unsigned char vc_uns; +typedef vector bool char vc_bool; + + +vi_sign vi_pack_1 (vll_sign a, vll_sign b) +{ + return __builtin_altivec_vpkudum (a, b); +} + +vi_sign vi_pack_2 (vll_sign a, vll_sign b) +{ + return vec_pack (a, b); +} + +vi_sign vi_pack_3 (vll_sign a, vll_sign b) +{ + return vec_vpkudum (a, b); +} + +vs_sign vs_pack_1 (vi_sign a, vi_sign b) +{ + return __builtin_altivec_vpkuwum (a, b); +} + +vs_sign vs_pack_2 (vi_sign a, vi_sign b) +{ + return vec_pack (a, b); +} + +vs_sign vs_pack_3 (vi_sign a, vi_sign b) +{ + return vec_vpkuwum (a, b); +} + +vc_sign vc_pack_1 (vs_sign a, vs_sign b) +{ + return __builtin_altivec_vpkuhum (a, b); +} + +vc_sign vc_pack_2 (vs_sign a, vs_sign b) +{ + return vec_pack (a, b); +} + +vc_sign vc_pack_3 (vs_sign a, vs_sign b) +{ + return vec_vpkuhum (a, b); +} + +vll_sign vll_unpack_hi_1 (vi_sign a) +{ + return __builtin_altivec_vupkhsw (a); +} + +vll_sign vll_unpack_hi_2 (vi_sign a) +{ + return vec_unpackh (a); +} + +vll_sign vll_unpack_hi_3 (vi_sign a) +{ + return __builtin_vec_vupkhsw (a); +} + +vll_sign vll_unpack_lo_1 (vi_sign a) +{ + return vec_vupklsw (a); +} + +vll_sign vll_unpack_lo_2 (vi_sign a) +{ + return vec_unpackl (a); +} + +vll_sign vll_unpack_lo_3 (vi_sign a) +{ + return vec_vupklsw (a); +} + +/* { dg-final { scan-assembler-times "vpkudum" 3 } } */ +/* { dg-final { scan-assembler-times "vpkuwum" 3 } } */ +/* { dg-final { scan-assembler-times "vpkuhum" 3 } } */ +/* { dg-final { scan-assembler-times "vupklsw" 3 } } */ +/* { dg-final { scan-assembler-times "vupkhsw" 3 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-4.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-4.c new file mode 100644 index 000000000..518a6aa5e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-4.c @@ -0,0 +1,249 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O3 -ftree-vectorize -fvect-cost-model" } */ + +#include <altivec.h> + +typedef vector long long vll_sign; +typedef vector unsigned long long vll_uns; +typedef vector bool long long vll_bool; + +typedef vector int vi_sign; +typedef vector unsigned int vi_uns; +typedef vector bool int vi_bool; + +typedef vector short vs_sign; +typedef vector unsigned short vs_uns; +typedef vector bool short vs_bool; + +typedef vector signed char vc_sign; +typedef vector unsigned char vc_uns; +typedef vector bool char vc_bool; + +vll_sign vll_clz_1 (vll_sign a) +{ + return __builtin_altivec_vclzd (a); +} + +vll_sign vll_clz_2 (vll_sign a) +{ + return vec_vclz (a); +} + +vll_sign vll_clz_3 (vll_sign a) +{ + return vec_vclzd (a); +} + +vll_uns vll_clz_4 (vll_uns a) +{ + return vec_vclz (a); +} + +vll_uns vll_clz_5 (vll_uns a) +{ + return vec_vclzd (a); +} + +vi_sign vi_clz_1 (vi_sign a) +{ + return __builtin_altivec_vclzw (a); +} + +vi_sign vi_clz_2 (vi_sign a) +{ + return vec_vclz (a); +} + +vi_sign vi_clz_3 (vi_sign a) +{ + return vec_vclzw (a); +} + +vi_uns vi_clz_4 (vi_uns a) +{ + return vec_vclz (a); +} + +vi_uns vi_clz_5 (vi_uns a) +{ + return vec_vclzw (a); +} + +vs_sign vs_clz_1 (vs_sign a) +{ + return __builtin_altivec_vclzh (a); +} + +vs_sign vs_clz_2 (vs_sign a) +{ + return vec_vclz (a); +} + +vs_sign vs_clz_3 (vs_sign a) +{ + return vec_vclzh (a); +} + +vs_uns vs_clz_4 (vs_uns a) +{ + return vec_vclz (a); +} + +vs_uns vs_clz_5 (vs_uns a) +{ + return vec_vclzh (a); +} + +vc_sign vc_clz_1 (vc_sign a) +{ + return __builtin_altivec_vclzb (a); +} + +vc_sign vc_clz_2 (vc_sign a) +{ + return vec_vclz (a); +} + +vc_sign vc_clz_3 (vc_sign a) +{ + return vec_vclzb (a); +} + +vc_uns vc_clz_4 (vc_uns a) +{ + return vec_vclz (a); +} + +vc_uns vc_clz_5 (vc_uns a) +{ + return vec_vclzb (a); +} + +vll_sign vll_popcnt_1 (vll_sign a) +{ + return __builtin_altivec_vpopcntd (a); +} + +vll_sign vll_popcnt_2 (vll_sign a) +{ + return vec_vpopcnt (a); +} + +vll_sign vll_popcnt_3 (vll_sign a) +{ + return vec_vpopcntd (a); +} + +vll_uns vll_popcnt_4 (vll_uns a) +{ + return vec_vpopcnt (a); +} + +vll_uns vll_popcnt_5 (vll_uns a) +{ + return vec_vpopcntd (a); +} + +vi_sign vi_popcnt_1 (vi_sign a) +{ + return __builtin_altivec_vpopcntw (a); +} + +vi_sign vi_popcnt_2 (vi_sign a) +{ + return vec_vpopcnt (a); +} + +vi_sign vi_popcnt_3 (vi_sign a) +{ + return vec_vpopcntw (a); +} + +vi_uns vi_popcnt_4 (vi_uns a) +{ + return vec_vpopcnt (a); +} + +vi_uns vi_popcnt_5 (vi_uns a) +{ + return vec_vpopcntw (a); +} + +vs_sign vs_popcnt_1 (vs_sign a) +{ + return __builtin_altivec_vpopcnth (a); +} + +vs_sign vs_popcnt_2 (vs_sign a) +{ + return vec_vpopcnt (a); +} + +vs_sign vs_popcnt_3 (vs_sign a) +{ + return vec_vpopcnth (a); +} + +vs_uns vs_popcnt_4 (vs_uns a) +{ + return vec_vpopcnt (a); +} + +vs_uns vs_popcnt_5 (vs_uns a) +{ + return vec_vpopcnth (a); +} + +vc_sign vc_popcnt_1 (vc_sign a) +{ + return __builtin_altivec_vpopcntb (a); +} + +vc_sign vc_popcnt_2 (vc_sign a) +{ + return vec_vpopcnt (a); +} + +vc_sign vc_popcnt_3 (vc_sign a) +{ + return vec_vpopcntb (a); +} + +vc_uns vc_popcnt_4 (vc_uns a) +{ + return vec_vpopcnt (a); +} + +vc_uns vc_popcnt_5 (vc_uns a) +{ + return vec_vpopcntb (a); +} + +vc_uns vc_gbb_1 (vc_uns a) +{ + return __builtin_altivec_vgbbd (a); +} + +vc_sign vc_gbb_2 (vc_sign a) +{ + return vec_vgbbd (a); +} + +vc_uns vc_gbb_3 (vc_uns a) +{ + return vec_vgbbd (a); +} + +/* { dg-final { scan-assembler-times "vclzd" 5 } } */ +/* { dg-final { scan-assembler-times "vclzw" 5 } } */ +/* { dg-final { scan-assembler-times "vclzh" 5 } } */ +/* { dg-final { scan-assembler-times "vclzb" 5 } } */ + +/* { dg-final { scan-assembler-times "vpopcntd" 5 } } */ +/* { dg-final { scan-assembler-times "vpopcntw" 5 } } */ +/* { dg-final { scan-assembler-times "vpopcnth" 5 } } */ +/* { dg-final { scan-assembler-times "vpopcntb" 5 } } */ + +/* { dg-final { scan-assembler-times "vgbbd" 3 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-5.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-5.c new file mode 100644 index 000000000..2e64551ff --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-5.c @@ -0,0 +1,105 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model -fno-unroll-loops -fno-unroll-all-loops" } */ + +#include <altivec.h> + +#ifndef SIZE +#define SIZE 1024 +#endif + +#ifndef ALIGN +#define ALIGN 32 +#endif + +#ifndef ATTR_ALIGN +#define ATTR_ALIGN __attribute__((__aligned__(ALIGN))) +#endif + +#define DOIT(TYPE, PREFIX) \ +TYPE PREFIX ## _eqv_builtin (TYPE a, TYPE b) \ +{ \ + return vec_eqv (a, b); \ +} \ + \ +TYPE PREFIX ## _eqv_arith (TYPE a, TYPE b) \ +{ \ + return ~(a ^ b); \ +} \ + \ +TYPE PREFIX ## _nand_builtin (TYPE a, TYPE b) \ +{ \ + return vec_nand (a, b); \ +} \ + \ +TYPE PREFIX ## _nand_arith1 (TYPE a, TYPE b) \ +{ \ + return ~(a & b); \ +} \ + \ +TYPE PREFIX ## _nand_arith2 (TYPE a, TYPE b) \ +{ \ + return (~a) | (~b); \ +} \ + \ +TYPE PREFIX ## _orc_builtin (TYPE a, TYPE b) \ +{ \ + return vec_orc (a, b); \ +} \ + \ +TYPE PREFIX ## _orc_arith1 (TYPE a, TYPE b) \ +{ \ + return (~ a) | b; \ +} \ + \ +TYPE PREFIX ## _orc_arith2 (TYPE a, TYPE b) \ +{ \ + return a | (~ b); \ +} + +#define DOIT_FLOAT(TYPE, PREFIX) \ +TYPE PREFIX ## _eqv_builtin (TYPE a, TYPE b) \ +{ \ + return vec_eqv (a, b); \ +} \ + \ +TYPE PREFIX ## _nand_builtin (TYPE a, TYPE b) \ +{ \ + return vec_nand (a, b); \ +} \ + \ +TYPE PREFIX ## _orc_builtin (TYPE a, TYPE b) \ +{ \ + return vec_orc (a, b); \ +} + +typedef vector signed char sign_char_vec; +typedef vector short sign_short_vec; +typedef vector int sign_int_vec; +typedef vector long long sign_llong_vec; + +typedef vector unsigned char uns_char_vec; +typedef vector unsigned short uns_short_vec; +typedef vector unsigned int uns_int_vec; +typedef vector unsigned long long uns_llong_vec; + +typedef vector float float_vec; +typedef vector double double_vec; + +DOIT(sign_char_vec, sign_char) +DOIT(sign_short_vec, sign_short) +DOIT(sign_int_vec, sign_int) +DOIT(sign_llong_vec, sign_llong) + +DOIT(uns_char_vec, uns_char) +DOIT(uns_short_vec, uns_short) +DOIT(uns_int_vec, uns_int) +DOIT(uns_llong_vec, uns_llong) + +DOIT_FLOAT(float_vec, float) +DOIT_FLOAT(double_vec, double) + +/* { dg-final { scan-assembler-times "xxleqv" 18 } } */ +/* { dg-final { scan-assembler-times "xxlnand" 26 } } */ +/* { dg-final { scan-assembler-times "xxlorc" 26 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-6.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-6.c new file mode 100644 index 000000000..8b81781c6 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-6.c @@ -0,0 +1,10 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +vector float dbl_to_float_p8 (double x) { return __builtin_vsx_xscvdpspn (x); } +double float_to_dbl_p8 (vector float x) { return __builtin_vsx_xscvspdpn (x); } + +/* { dg-final { scan-assembler "xscvdpspn" } } */ +/* { dg-final { scan-assembler "xscvspdpn" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-7.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-7.c new file mode 100644 index 000000000..45a300fb9 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-builtin-7.c @@ -0,0 +1,32 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +#include <altivec.h> + +typedef vector int v_sign; +typedef vector unsigned int v_uns; + +v_sign even_sign (v_sign a, v_sign b) +{ + return vec_vmrgew (a, b); +} + +v_uns even_uns (v_uns a, v_uns b) +{ + return vec_vmrgew (a, b); +} + +v_sign odd_sign (v_sign a, v_sign b) +{ + return vec_vmrgow (a, b); +} + +v_uns odd_uns (v_uns a, v_uns b) +{ + return vec_vmrgow (a, b); +} + +/* { dg-final { scan-assembler-times "vmrgew" 2 } } */ +/* { dg-final { scan-assembler-times "vmrgow" 2 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-fp.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-fp.c new file mode 100644 index 000000000..3cfd8161d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-fp.c @@ -0,0 +1,139 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -mupper-regs-df -mupper-regs-sf -fno-math-errno" } */ + +float abs_sf (float *p) +{ + float f = *p; + __asm__ ("# reg %x0" : "+v" (f)); + return __builtin_fabsf (f); +} + +float nabs_sf (float *p) +{ + float f = *p; + __asm__ ("# reg %x0" : "+v" (f)); + return - __builtin_fabsf (f); +} + +float neg_sf (float *p) +{ + float f = *p; + __asm__ ("# reg %x0" : "+v" (f)); + return - f; +} + +float add_sf (float *p, float *q) +{ + float f1 = *p; + float f2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (f1), "+v" (f2)); + return f1 + f2; +} + +float sub_sf (float *p, float *q) +{ + float f1 = *p; + float f2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (f1), "+v" (f2)); + return f1 - f2; +} + +float mul_sf (float *p, float *q) +{ + float f1 = *p; + float f2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (f1), "+v" (f2)); + return f1 * f2; +} + +float div_sf (float *p, float *q) +{ + float f1 = *p; + float f2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (f1), "+v" (f2)); + return f1 / f2; +} + +float sqrt_sf (float *p) +{ + float f = *p; + __asm__ ("# reg %x0" : "+v" (f)); + return __builtin_sqrtf (f); +} + + +double abs_df (double *p) +{ + double d = *p; + __asm__ ("# reg %x0" : "+v" (d)); + return __builtin_fabs (d); +} + +double nabs_df (double *p) +{ + double d = *p; + __asm__ ("# reg %x0" : "+v" (d)); + return - __builtin_fabs (d); +} + +double neg_df (double *p) +{ + double d = *p; + __asm__ ("# reg %x0" : "+v" (d)); + return - d; +} + +double add_df (double *p, double *q) +{ + double d1 = *p; + double d2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (d1), "+v" (d2)); + return d1 + d2; +} + +double sub_df (double *p, double *q) +{ + double d1 = *p; + double d2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (d1), "+v" (d2)); + return d1 - d2; +} + +double mul_df (double *p, double *q) +{ + double d1 = *p; + double d2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (d1), "+v" (d2)); + return d1 * d2; +} + +double div_df (double *p, double *q) +{ + double d1 = *p; + double d2 = *q; + __asm__ ("# reg %x0, %x1" : "+v" (d1), "+v" (d2)); + return d1 / d2; +} + +double sqrt_df (float *p) +{ + double d = *p; + __asm__ ("# reg %x0" : "+v" (d)); + return __builtin_sqrt (d); +} + +/* { dg-final { scan-assembler "xsabsdp" } } */ +/* { dg-final { scan-assembler "xsadddp" } } */ +/* { dg-final { scan-assembler "xsaddsp" } } */ +/* { dg-final { scan-assembler "xsdivdp" } } */ +/* { dg-final { scan-assembler "xsdivsp" } } */ +/* { dg-final { scan-assembler "xsmuldp" } } */ +/* { dg-final { scan-assembler "xsmulsp" } } */ +/* { dg-final { scan-assembler "xsnabsdp" } } */ +/* { dg-final { scan-assembler "xsnegdp" } } */ +/* { dg-final { scan-assembler "xssqrtdp" } } */ +/* { dg-final { scan-assembler "xssqrtsp" } } */ +/* { dg-final { scan-assembler "xssubdp" } } */ +/* { dg-final { scan-assembler "xssubsp" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-int128-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-int128-1.c new file mode 100644 index 000000000..86bde3241 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-int128-1.c @@ -0,0 +1,85 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O3 -mvsx-timode" } */ + +#include <altivec.h> + +#ifndef TYPE +#define TYPE vector __int128_t +#endif + +TYPE +do_addcuq (TYPE p, TYPE q) +{ + return __builtin_vec_vaddcuq (p, q); +} + +TYPE +do_adduqm (TYPE p, TYPE q) +{ + return __builtin_vec_add (p, q); +} + +TYPE +do_addeuqm (TYPE p, TYPE q, TYPE r) +{ + return __builtin_vec_vaddeuqm (p, q, r); +} + +TYPE +do_addecuq (TYPE p, TYPE q, TYPE r) +{ + return __builtin_vec_vaddecuq (p, q, r); +} + +TYPE +do_subeuqm (TYPE p, TYPE q, TYPE r) +{ + return __builtin_vec_vsubeuqm (p, q, r); +} + +TYPE +do_subecuq (TYPE p, TYPE q, TYPE r) +{ + return __builtin_vec_vsubecuq (p, q, r); +} + +TYPE +do_subcuq (TYPE p, TYPE q) +{ + return __builtin_vec_vsubcuq (p, q); +} + +TYPE +do_subuqm (TYPE p, TYPE q) +{ + return __builtin_vec_vsubuqm (p, q); +} + +TYPE +do_zero (void) +{ + return (TYPE) { 0 }; +} + +TYPE +do_minus_one (void) +{ + return (TYPE) { -1 }; +} + +/* { dg-final { scan-assembler "vaddcuq" } } */ +/* { dg-final { scan-assembler "vadduqm" } } */ +/* { dg-final { scan-assembler "vaddecuq" } } */ +/* { dg-final { scan-assembler "vaddeuqm" } } */ +/* { dg-final { scan-assembler "vsubecuq" } } */ +/* { dg-final { scan-assembler "vsubeuqm" } } */ +/* { dg-final { scan-assembler "vsubcuq" } } */ +/* { dg-final { scan-assembler "vsubuqm" } } */ +/* { dg-final { scan-assembler-not "mtvsrd" } } */ +/* { dg-final { scan-assembler-not "mfvsrd" } } */ +/* { dg-final { scan-assembler-not "ori 2,2,0" } } */ +/* { dg-final { scan-assembler-not "xxpermdi" } } */ +/* { dg-final { scan-assembler-not "stxvd2x" } } */ +/* { dg-final { scan-assembler-not "stxvw4x" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-int128-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-int128-2.c new file mode 100644 index 000000000..1064894dc --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-int128-2.c @@ -0,0 +1,177 @@ +/* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target p8vector_hw } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +#include <stddef.h> +#include <stdlib.h> +#include <altivec.h> + +#ifdef DEBUG +#include <stdio.h> +#define UNUSED + +#ifdef __LITTLE_ENDIAN__ +#define HI_WORD 1 +#define LO_WORD 0 +#else +#define HI_WORD 0 +#define LO_WORD 1 +#endif + +#else +#define UNUSED __attribute__((__unused__)) +#endif + +#ifndef S_TYPE +#define S_TYPE __uint128_t +#endif + +#ifndef V_TYPE +#define V_TYPE vector S_TYPE +#endif + +static int compare (S_TYPE, V_TYPE, const char *, const char *) + __attribute__((__noinline__)); + +static int +compare (S_TYPE scalar, + V_TYPE vect, + const char *nl UNUSED, + const char *which UNUSED) +{ + unsigned long scalar_lo = (unsigned long) scalar; + unsigned long scalar_hi = (unsigned long) (scalar >> 64); + unsigned long vect_lo; + unsigned long vect_hi; + vector long long tmp; + int ret; + + __asm__ ("mfvsrd %0,%x3\n\t" + "xxpermdi %x2,%x3,%x3,3\n\t" + "mfvsrd %1,%x2" + : "=r" (vect_hi), + "=r" (vect_lo), + "=wa" (tmp) + : "wa" (vect)); + + ret = (scalar_lo != vect_lo) || (scalar_hi != vect_hi); + +#ifdef DEBUG + printf ("%s%s: 0x%.16lx %.16lx %s 0x%.16lx %.16lx\n", + nl, which, + scalar_hi, scalar_lo, + (ret) ? "!=" : "==", + vect_hi, vect_lo); + + fflush (stdout); +#endif + + return ret; +} + +static void convert_via_mem (V_TYPE *, S_TYPE *) + __attribute__((__noinline__)); + +static void +convert_via_mem (V_TYPE *v, S_TYPE *s) +{ + *v = (V_TYPE) { *s }; + __asm__ volatile ("nop" + : "+m" (*s), "+m" (*v) + : + : "memory"); + +} + + +/* Check if vadduqm returns the same values as normal 128-bit add. */ + +/* Values to add together. */ +const static struct { + unsigned long hi_1; + unsigned long lo_1; + unsigned long hi_2; + unsigned long lo_2; +} values[] = { + { 0x0000000000000000UL, 0xfffffffffffffffeUL, + 0x0000000000000000UL, 0x0000000000000002UL }, + { 0x0000000000000000UL, 0x0000000000000002UL, + 0x0000000000000000UL, 0xfffffffffffffffeUL }, + { 0xffffffffffffffffUL, 0xfffffffffffffffeUL, + 0x0000000000000000UL, 0x0000000000000002UL }, + { 0xfffffffffffffff2UL, 0xffffffffffffffffUL, + 0x0000000000000002UL, 0x0000000000000000UL }, + { 0x7fffffffffffffffUL, 0xfffffffffffffffeUL, + 0x0000000000000000UL, 0x0000000000000002UL }, + { 0x7ffffffffffffff2UL, 0xffffffffffffffffUL, + 0x0000000000000002UL, 0x0000000000000000UL }, +}; + +int +main (void) +{ + int reg_errors = 0; + int mem_errors = 0; + size_t i; + const char *nl = ""; + + for (i = 0; i < sizeof (values) / sizeof (values[0]); i++) + { + S_TYPE s_reg_res, s_reg_in1, s_reg_in2, s_mem_res, s_mem_in1, s_mem_in2; + V_TYPE v_reg_res, v_reg_in1, v_reg_in2, v_mem_res, v_mem_in1, v_mem_in2; + + s_reg_in1 = ((((S_TYPE)values[i].hi_1 << 64)) + ((S_TYPE)values[i].lo_1)); + reg_errors += compare (s_reg_in1, (V_TYPE) { s_reg_in1 }, nl, "reg, in1"); + + s_reg_in2 = ((((S_TYPE)values[i].hi_2 << 64)) + ((S_TYPE)values[i].lo_2)); + reg_errors += compare (s_reg_in2, (V_TYPE) { s_reg_in2 }, "", "reg, in2"); + + s_reg_res = s_reg_in1 + s_reg_in2; + + v_reg_in1 = (V_TYPE) { s_reg_in1 }; + v_reg_in2 = (V_TYPE) { s_reg_in2 }; + v_reg_res = vec_vadduqm (v_reg_in1, v_reg_in2); + reg_errors += compare (s_reg_res, v_reg_res, "", "reg, res"); + + s_mem_in1 = s_reg_in1; + convert_via_mem (&v_mem_in1, &s_mem_in1); + mem_errors += compare (s_mem_in1, (V_TYPE) { s_mem_in1 }, "\n", "mem, in1"); + + s_mem_in2 = s_reg_in2; + convert_via_mem (&v_mem_in2, &s_mem_in2); + mem_errors += compare (s_mem_in2, (V_TYPE) { s_mem_in2 }, "", "mem, in2"); + + s_mem_res = s_mem_in1 + s_mem_in2; + v_mem_res = vec_vadduqm (v_mem_in1, v_mem_in2); + mem_errors += compare (s_mem_res, v_mem_res, "", "mem, res"); + + nl = "\n"; + } + +#ifdef DEBUG + putchar ('\n'); + + if (!reg_errors) + fputs ("no errors found on register operations\n", stdout); + else + printf ("%d error%s found on register operations\n", + reg_errors, + (reg_errors == 1) ? "s" : ""); + + if (!mem_errors) + fputs ("no errors found on memory operations\n", stdout); + else + printf ("%d error%s found on memory operations\n", + mem_errors, + (mem_errors == 1) ? "s" : ""); + + fflush (stdout); +#endif + + if ((reg_errors + mem_errors) != 0) + abort (); + + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-ldst.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-ldst.c new file mode 100644 index 000000000..33f19991f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-ldst.c @@ -0,0 +1,42 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -mupper-regs-df -mupper-regs-sf" } */ + +float load_sf (float *p) +{ + float f = *p; + __asm__ ("# reg %x0" : "+v" (f)); + return f; +} + +double load_df (double *p) +{ + double d = *p; + __asm__ ("# reg %x0" : "+v" (d)); + return d; +} + +double load_dfsf (float *p) +{ + double d = (double) *p; + __asm__ ("# reg %x0" : "+v" (d)); + return d; +} + +void store_sf (float *p, float f) +{ + __asm__ ("# reg %x0" : "+v" (f)); + *p = f; +} + +void store_df (double *p, double d) +{ + __asm__ ("# reg %x0" : "+v" (d)); + *p = d; +} + +/* { dg-final { scan-assembler "lxsspx" } } */ +/* { dg-final { scan-assembler "lxsdx" } } */ +/* { dg-final { scan-assembler "stxsspx" } } */ +/* { dg-final { scan-assembler "stxsdx" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vbpermq.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vbpermq.c new file mode 100644 index 000000000..d1664985a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vbpermq.c @@ -0,0 +1,27 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-O3 -mcpu=power8" } */ +/* { dg-final { scan-assembler "vbpermq" } } */ +/* { dg-final { scan-assembler "mfvsrd" } } */ +/* { dg-final { scan-assembler-not "stfd" } } */ +/* { dg-final { scan-assembler-not "stxvd2x" } } */ + +#include <altivec.h> + +#if __LITTLE_ENDIAN__ +#define OFFSET 1 +#else +#define OFFSET 0 +#endif + +long foos (vector signed char a, vector signed char b) +{ + return vec_extract (vec_vbpermq (a, b), OFFSET); +} + +long foou (vector unsigned char a, vector unsigned char b) +{ + return vec_extract (vec_vbpermq (a, b), OFFSET); +} + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-1.c new file mode 100644 index 000000000..9a975bd6f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-1.c @@ -0,0 +1,200 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model -fno-unroll-loops -fno-unroll-all-loops" } */ + +#ifndef SIZE +#define SIZE 1024 +#endif + +#ifndef ALIGN +#define ALIGN 32 +#endif + +#ifndef TYPE +#define TYPE long long +#endif + +#ifndef SIGN_TYPE +#define SIGN_TYPE signed TYPE +#endif + +#ifndef UNS_TYPE +#define UNS_TYPE unsigned TYPE +#endif + +#define ALIGN_ATTR __attribute__((__aligned__(ALIGN))) + +SIGN_TYPE sa[SIZE] ALIGN_ATTR; +SIGN_TYPE sb[SIZE] ALIGN_ATTR; +SIGN_TYPE sc[SIZE] ALIGN_ATTR; + +UNS_TYPE ua[SIZE] ALIGN_ATTR; +UNS_TYPE ub[SIZE] ALIGN_ATTR; +UNS_TYPE uc[SIZE] ALIGN_ATTR; + +void +sign_add (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = sb[i] + sc[i]; +} + +void +sign_sub (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = sb[i] - sc[i]; +} + +void +sign_shift_left (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = sb[i] << sc[i]; +} + +void +sign_shift_right (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = sb[i] >> sc[i]; +} + +void +sign_max (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = (sb[i] > sc[i]) ? sb[i] : sc[i]; +} + +void +sign_min (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = (sb[i] < sc[i]) ? sb[i] : sc[i]; +} + +void +sign_abs (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = (sb[i] < 0) ? -sb[i] : sb[i]; /* xor, vsubudm, vmaxsd. */ +} + +void +sign_eq (SIGN_TYPE val1, SIGN_TYPE val2) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = (sb[i] == sc[i]) ? val1 : val2; +} + +void +sign_lt (SIGN_TYPE val1, SIGN_TYPE val2) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + sa[i] = (sb[i] < sc[i]) ? val1 : val2; +} + +void +uns_add (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = ub[i] + uc[i]; +} + +void +uns_sub (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = ub[i] - uc[i]; +} + +void +uns_shift_left (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = ub[i] << uc[i]; +} + +void +uns_shift_right (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = ub[i] >> uc[i]; +} + +void +uns_max (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = (ub[i] > uc[i]) ? ub[i] : uc[i]; +} + +void +uns_min (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = (ub[i] < uc[i]) ? ub[i] : uc[i]; +} + +void +uns_eq (UNS_TYPE val1, UNS_TYPE val2) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = (ub[i] == uc[i]) ? val1 : val2; +} + +void +uns_lt (UNS_TYPE val1, UNS_TYPE val2) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + ua[i] = (ub[i] < uc[i]) ? val1 : val2; +} + +/* { dg-final { scan-assembler-times "\[\t \]vaddudm\[\t \]" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vsubudm\[\t \]" 3 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vmaxsd\[\t \]" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vmaxud\[\t \]" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vminsd\[\t \]" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vminud\[\t \]" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vsld\[\t \]" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vsrad\[\t \]" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vsrd\[\t \]" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vcmpequd\[\t \]" 2 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vcmpgtsd\[\t \]" 1 } } */ +/* { dg-final { scan-assembler-times "\[\t \]vcmpgtud\[\t \]" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-2.c new file mode 100644 index 000000000..8feba0a13 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-2.c @@ -0,0 +1,30 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model" } */ + +#include <stddef.h> + +#ifndef SIZE +#define SIZE 1024 +#endif + +#ifndef ALIGN +#define ALIGN 32 +#endif + +#define ALIGN_ATTR __attribute__((__aligned__(ALIGN))) + +long long sign_ll[SIZE] ALIGN_ATTR; +int sign_i [SIZE] ALIGN_ATTR; + +void copy_int_to_long_long (void) +{ + size_t i; + + for (i = 0; i < SIZE; i++) + sign_ll[i] = sign_i[i]; +} + +/* { dg-final { scan-assembler "vupkhsw" } } */ +/* { dg-final { scan-assembler "vupklsw" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-3.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-3.c new file mode 100644 index 000000000..570f2e599 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-3.c @@ -0,0 +1,29 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model" } */ + +#include <stddef.h> + +#ifndef SIZE +#define SIZE 1024 +#endif + +#ifndef ALIGN +#define ALIGN 32 +#endif + +#define ALIGN_ATTR __attribute__((__aligned__(ALIGN))) + +long long sign_ll[SIZE] ALIGN_ATTR; +int sign_i [SIZE] ALIGN_ATTR; + +void copy_long_long_to_int (void) +{ + size_t i; + + for (i = 0; i < SIZE; i++) + sign_i[i] = sign_ll[i]; +} + +/* { dg-final { scan-assembler "vpkudum" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-4.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-4.c new file mode 100644 index 000000000..90df88680 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-4.c @@ -0,0 +1,69 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model -fno-unroll-loops -fno-unroll-all-loops" } */ + +#ifndef SIZE +#define SIZE 1024 +#endif + +#ifndef ALIGN +#define ALIGN 32 +#endif + +#define ALIGN_ATTR __attribute__((__aligned__(ALIGN))) + +#define DO_BUILTIN(PREFIX, TYPE, CLZ, POPCNT) \ +TYPE PREFIX ## _a[SIZE] ALIGN_ATTR; \ +TYPE PREFIX ## _b[SIZE] ALIGN_ATTR; \ + \ +void \ +PREFIX ## _clz (void) \ +{ \ + unsigned long i; \ + \ + for (i = 0; i < SIZE; i++) \ + PREFIX ## _a[i] = CLZ (PREFIX ## _b[i]); \ +} \ + \ +void \ +PREFIX ## _popcnt (void) \ +{ \ + unsigned long i; \ + \ + for (i = 0; i < SIZE; i++) \ + PREFIX ## _a[i] = POPCNT (PREFIX ## _b[i]); \ +} + +#if !defined(DO_LONG_LONG) && !defined(DO_LONG) && !defined(DO_INT) && !defined(DO_SHORT) && !defined(DO_CHAR) +#define DO_INT 1 +#endif + +#if DO_LONG_LONG +/* At the moment, only int is auto vectorized. */ +DO_BUILTIN (sll, long long, __builtin_clzll, __builtin_popcountll) +DO_BUILTIN (ull, unsigned long long, __builtin_clzll, __builtin_popcountll) +#endif + +#if defined(_ARCH_PPC64) && DO_LONG +DO_BUILTIN (sl, long, __builtin_clzl, __builtin_popcountl) +DO_BUILTIN (ul, unsigned long, __builtin_clzl, __builtin_popcountl) +#endif + +#if DO_INT +DO_BUILTIN (si, int, __builtin_clz, __builtin_popcount) +DO_BUILTIN (ui, unsigned int, __builtin_clz, __builtin_popcount) +#endif + +#if DO_SHORT +DO_BUILTIN (ss, short, __builtin_clz, __builtin_popcount) +DO_BUILTIN (us, unsigned short, __builtin_clz, __builtin_popcount) +#endif + +#if DO_CHAR +DO_BUILTIN (sc, signed char, __builtin_clz, __builtin_popcount) +DO_BUILTIN (uc, unsigned char, __builtin_clz, __builtin_popcount) +#endif + +/* { dg-final { scan-assembler-times "vclzw" 2 } } */ +/* { dg-final { scan-assembler-times "vpopcntw" 2 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-5.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-5.c new file mode 100644 index 000000000..17563bf47 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/p8vector-vectorize-5.c @@ -0,0 +1,87 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O2 -ftree-vectorize -fvect-cost-model -fno-unroll-loops -fno-unroll-all-loops" } */ + +#ifndef SIZE +#define SIZE 1024 +#endif + +#ifndef ALIGN +#define ALIGN 32 +#endif + +#ifndef ATTR_ALIGN +#define ATTR_ALIGN __attribute__((__aligned__(ALIGN))) +#endif + +#ifndef TYPE +#define TYPE unsigned int +#endif + +TYPE in1 [SIZE] ATTR_ALIGN; +TYPE in2 [SIZE] ATTR_ALIGN; +TYPE eqv [SIZE] ATTR_ALIGN; +TYPE nand1[SIZE] ATTR_ALIGN; +TYPE nand2[SIZE] ATTR_ALIGN; +TYPE orc1 [SIZE] ATTR_ALIGN; +TYPE orc2 [SIZE] ATTR_ALIGN; + +void +do_eqv (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + { + eqv[i] = ~(in1[i] ^ in2[i]); + } +} + +void +do_nand1 (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + { + nand1[i] = ~(in1[i] & in2[i]); + } +} + +void +do_nand2 (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + { + nand2[i] = (~in1[i]) | (~in2[i]); + } +} + +void +do_orc1 (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + { + orc1[i] = (~in1[i]) | in2[i]; + } +} + +void +do_orc2 (void) +{ + unsigned long i; + + for (i = 0; i < SIZE; i++) + { + orc1[i] = in1[i] | (~in2[i]); + } +} + +/* { dg-final { scan-assembler-times "xxleqv" 1 } } */ +/* { dg-final { scan-assembler-times "xxlnand" 2 } } */ +/* { dg-final { scan-assembler-times "xxlorc" 2 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack01.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack01.c new file mode 100644 index 000000000..efac4087c --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack01.c @@ -0,0 +1,91 @@ +/* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target p8vector_hw } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +#include <stddef.h> +#include <stdlib.h> +#include <altivec.h> + +#ifdef DEBUG +#include <stdio.h> +#endif + +typedef __int128_t __attribute__((__vector_size__(16))) vector_128_t; +typedef __int128_t scalar_128_t; +typedef unsigned long long scalar_64_t; + +volatile scalar_64_t one = 1; +volatile scalar_64_t two = 2; + +int +main (void) +{ + scalar_128_t a = (((scalar_128_t)one) << 64) | ((scalar_128_t)two); + vector_128_t v1 = (vector_128_t) { a }; + vector_128_t v2 = __builtin_pack_vector_int128 (one, two); + scalar_64_t x0 = __builtin_unpack_vector_int128 (v1, 0); + scalar_64_t x1 = __builtin_unpack_vector_int128 (v1, 1); + vector_128_t v3 = __builtin_pack_vector_int128 (x0, x1); + + size_t i; + union { + scalar_128_t i128; + vector_128_t v128; + scalar_64_t u64; + unsigned char uc[sizeof (scalar_128_t)]; + char c[sizeof (scalar_128_t)]; + } u, u2; + +#ifdef DEBUG + { + printf ("a = 0x"); + u.i128 = a; + for (i = 0; i < sizeof (scalar_128_t); i++) + printf ("%.2x", u.uc[i]); + + printf ("\nv1 = 0x"); + u.v128 = v1; + for (i = 0; i < sizeof (scalar_128_t); i++) + printf ("%.2x", u.uc[i]); + + printf ("\nv2 = 0x"); + u.v128 = v2; + for (i = 0; i < sizeof (scalar_128_t); i++) + printf ("%.2x", u.uc[i]); + + printf ("\nv3 = 0x"); + u.v128 = v3; + for (i = 0; i < sizeof (scalar_128_t); i++) + printf ("%.2x", u.uc[i]); + + printf ("\nx0 = 0x"); + u.u64 = x0; + for (i = 0; i < sizeof (scalar_64_t); i++) + printf ("%.2x", u.uc[i]); + + printf ("\nx1 = 0x"); + u.u64 = x1; + for (i = 0; i < sizeof (scalar_64_t); i++) + printf ("%.2x", u.uc[i]); + + printf ("\n"); + } +#endif + + u2.i128 = a; + u.v128 = v1; + if (memcmp (u.c, u2.c, sizeof (scalar_128_t)) != 0) + abort (); + + u.v128 = v2; + if (memcmp (u.c, u2.c, sizeof (scalar_128_t)) != 0) + abort (); + + u.v128 = v3; + if (memcmp (u.c, u2.c, sizeof (scalar_128_t)) != 0) + abort (); + + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack02.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack02.c new file mode 100644 index 000000000..584d6c292 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack02.c @@ -0,0 +1,95 @@ +/* { dg-do run { target { powerpc*-*-linux* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_fprs } */ +/* { dg-options "-O2 -mhard-float" } */ + +#include <stddef.h> +#include <stdlib.h> +#include <math.h> + +#ifdef DEBUG +#include <stdio.h> +#endif + +int +main (void) +{ + double high = pow (2.0, 60); + double low = 2.0; + long double a = ((long double)high) + ((long double)low); + double x0 = __builtin_unpack_longdouble (a, 0); + double x1 = __builtin_unpack_longdouble (a, 1); + long double b = __builtin_pack_longdouble (x0, x1); + +#ifdef DEBUG + { + size_t i; + union { + long double ld; + double d; + unsigned char uc[sizeof (long double)]; + char c[sizeof (long double)]; + } u; + + printf ("a = 0x"); + u.ld = a; + for (i = 0; i < sizeof (long double); i++) + printf ("%.2x", u.uc[i]); + + printf (", %Lg\n", a); + + printf ("b = 0x"); + u.ld = b; + for (i = 0; i < sizeof (long double); i++) + printf ("%.2x", u.uc[i]); + + printf (", %Lg\n", b); + + printf ("hi = 0x"); + u.d = high; + for (i = 0; i < sizeof (double); i++) + printf ("%.2x", u.uc[i]); + + printf (",%*s %g\n", (int)(2 * (sizeof (long double) - sizeof (double))), "", high); + + printf ("lo = 0x"); + u.d = low; + for (i = 0; i < sizeof (double); i++) + printf ("%.2x", u.uc[i]); + + printf (",%*s %g\n", (int)(2 * (sizeof (long double) - sizeof (double))), "", low); + + printf ("x0 = 0x"); + u.d = x0; + for (i = 0; i < sizeof (double); i++) + printf ("%.2x", u.uc[i]); + + printf (",%*s %g\n", (int)(2 * (sizeof (long double) - sizeof (double))), "", x0); + + printf ("x1 = 0x"); + u.d = x1; + for (i = 0; i < sizeof (double); i++) + printf ("%.2x", u.uc[i]); + + printf (",%*s %g\n", (int)(2 * (sizeof (long double) - sizeof (double))), "", x1); + } +#endif + + if (high != x0) + abort (); + + if (low != x1) + abort (); + + if (a != b) + abort (); + + if (x0 != high) + abort (); + + if (x1 != low) + abort (); + + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack03.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack03.c new file mode 100644 index 000000000..dfaf2efa0 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pack03.c @@ -0,0 +1,88 @@ +/* { dg-do run { target { powerpc*-*-linux* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target dfp_hw } */ +/* { dg-options "-O2 -mhard-dfp" } */ + +#include <stddef.h> +#include <stdlib.h> +#include <math.h> + +#ifdef DEBUG +#include <stdio.h> +#endif + +int +main (void) +{ + _Decimal128 one = (_Decimal128)1.0; + _Decimal128 two = (_Decimal128)2.0; + _Decimal128 ten = (_Decimal128)10.0; + _Decimal128 a = one; + _Decimal128 b; + _Decimal128 c; + unsigned long long x0; + unsigned long long x1; + size_t i; + + for (i = 0; i < 25; i++) + a *= ten; + + a += two; + + x0 = __builtin_unpack_dec128 (a, 0); + x1 = __builtin_unpack_dec128 (a, 1); + b = __builtin_pack_dec128 (x0, x1); + c = __builtin_dscliq (one, 25) + two; + +#ifdef DEBUG + { + union { + _Decimal128 d; + unsigned long long ull; + unsigned char uc[sizeof (_Decimal128)]; + } u; + + printf ("a = 0x"); + u.d = a; + for (i = 0; i < sizeof (_Decimal128); i++) + printf ("%.2x", u.uc[i]); + + printf (", %Lg\n", (long double)a); + + printf ("b = 0x"); + u.d = b; + for (i = 0; i < sizeof (_Decimal128); i++) + printf ("%.2x", u.uc[i]); + + printf (", %Lg\n", (long double)b); + + printf ("c = 0x"); + u.d = c; + for (i = 0; i < sizeof (_Decimal128); i++) + printf ("%.2x", u.uc[i]); + + printf (", %Lg\n", (long double)c); + + printf ("x0 = 0x"); + u.ull = x0; + for (i = 0; i < sizeof (unsigned long long); i++) + printf ("%.2x", u.uc[i]); + + printf ("\nx1 = 0x"); + u.ull = x1; + for (i = 0; i < sizeof (unsigned long long); i++) + printf ("%.2x", u.uc[i]); + + printf ("\n"); + } +#endif + + if (a != b) + abort (); + + if (a != c) + abort (); + + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-1.c index 8fcb7fd7f..9dc730e0d 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-1.c @@ -89,8 +89,10 @@ typedef struct sf long a1; long a2; long a3; +#if _CALL_ELF != 2 long a4; long a5; +#endif parm_t slot[100]; } stack_frame_t; diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-2.c index a9883d9e3..e4825973b 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-2.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-2.c @@ -107,8 +107,10 @@ typedef struct sf long a1; long a2; long a3; +#if _CALL_ELF != 2 long a4; long a5; +#endif parm_t slot[100]; } stack_frame_t; @@ -119,6 +121,12 @@ typedef union vector int v; } vector_int_t; +#ifdef __LITTLE_ENDIAN__ +#define MAKE_SLOT(x, y) ((long)x | ((long)y << 32)) +#else +#define MAKE_SLOT(x, y) ((long)y | ((long)x << 32)) +#endif + /* Paramter passing. s : gpr 3 v : vpr 2 @@ -226,8 +234,8 @@ fcevv (char *s, ...) sp = __builtin_frame_address(0); sp = sp->backchain; - if (sp->slot[2].l != 0x100000002ULL - || sp->slot[4].l != 0x500000006ULL) + if (sp->slot[2].l != MAKE_SLOT (1, 2) + || sp->slot[4].l != MAKE_SLOT (5, 6)) abort(); } @@ -268,8 +276,8 @@ fciievv (char *s, int i, int j, ...) sp = __builtin_frame_address(0); sp = sp->backchain; - if (sp->slot[4].l != 0x100000002ULL - || sp->slot[6].l != 0x500000006ULL) + if (sp->slot[4].l != MAKE_SLOT (1, 2) + || sp->slot[6].l != MAKE_SLOT (5, 6)) abort(); } @@ -296,8 +304,8 @@ fcvevv (char *s, vector int x, ...) sp = __builtin_frame_address(0); sp = sp->backchain; - if (sp->slot[4].l != 0x100000002ULL - || sp->slot[6].l != 0x500000006ULL) + if (sp->slot[4].l != MAKE_SLOT (1, 2) + || sp->slot[6].l != MAKE_SLOT (5, 6)) abort(); } diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-dfp-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-dfp-1.c index eb54a653b..9bd5e28e0 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-dfp-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ppc64-abi-dfp-1.c @@ -33,15 +33,27 @@ reg_parms_t gparms; /* Wrapper to save the GPRs and FPRs and then jump to the real function. */ -#define WRAPPER(NAME) \ -__asm__ ("\t.globl\t" #NAME "_asm\n\t" \ +#if _CALL_ELF != 2 +#define FUNC_START(NAME) \ + "\t.globl\t" NAME "\n\t" \ ".section \".opd\",\"aw\"\n\t" \ ".align 3\n" \ - #NAME "_asm:\n\t" \ - ".quad .L." #NAME "_asm,.TOC.@tocbase,0\n\t" \ + NAME ":\n\t" \ + ".quad .L." NAME ",.TOC.@tocbase,0\n\t" \ + ".text\n\t" \ + ".type " NAME ", @function\n" \ + ".L." NAME ":\n\t" +#else +#define FUNC_START(NAME) \ + "\t.globl\t" NAME "\n\t" \ ".text\n\t" \ - ".type " #NAME "_asm, @function\n" \ - ".L." #NAME "_asm:\n\t" \ + NAME ":\n" \ + "0:\taddis 2,12,(.TOC.-0b)@ha\n\t" \ + "addi 2,2,(.TOC.-0b)@l\n\t" \ + ".localentry " NAME ",.-" NAME "\n\t" +#endif +#define WRAPPER(NAME) \ +__asm__ (FUNC_START (#NAME "_asm") \ "ld 11,gparms@got(2)\n\t" \ "std 3,0(11)\n\t" \ "std 4,8(11)\n\t" \ @@ -75,8 +87,10 @@ typedef struct sf long a1; long a2; long a3; +#if _CALL_ELF != 2 long a4; long a5; +#endif unsigned long slot[100]; } stack_frame_t; diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57744.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57744.c new file mode 100644 index 000000000..222fd6abd --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57744.c @@ -0,0 +1,39 @@ +/* { dg-do run { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O3" } */ + +void abort (void); + +typedef unsigned U_16 __attribute__((mode(TI))); + +extern int libat_compare_exchange_16 (U_16 *, U_16 *, U_16, int, int) + __attribute__((__noinline__)); + +/* PR 57744: lqarx/stqcx needs even/odd register pairs. The assembler will + complain if the compiler gets an odd/even register pair. Create a function + which has the 16 byte compare and exchange instructions, but don't actually + execute it, so that we can detect these failures on older machines. */ + +int +libat_compare_exchange_16 (U_16 *mptr, U_16 *eptr, U_16 newval, + int smodel, int fmodel __attribute__((unused))) +{ + if (((smodel) == 0)) + return __atomic_compare_exchange_n (mptr, eptr, newval, 0, 0, 0); + else if (((smodel) != 5)) + return __atomic_compare_exchange_n (mptr, eptr, newval, 0, 4, 0); + else + return __atomic_compare_exchange_n (mptr, eptr, newval, 0, 5, 0); +} + +U_16 a = 1, b = 1, c = -2; +volatile int do_test = 0; + +int main (void) +{ + if (do_test && !libat_compare_exchange_16 (&a, &b, c, 0, 0)) + abort (); + + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57949-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57949-1.c new file mode 100644 index 000000000..dac305a01 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57949-1.c @@ -0,0 +1,20 @@ +/* { dg-do compile { target { powerpc64*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc_elfv2 } { "*" } { "" } } */ +/* { dg-options "-O2 -mcpu=power7 -mno-compat-align-parm" } */ + +/* Verify that vs is 16-byte aligned with -mcompat-align-parm. */ + +typedef float v4sf __attribute__ ((vector_size (16))); +struct s { long m; v4sf v; }; +long n; +v4sf ve; + +void pr57949 (long d1, long d2, long d3, long d4, long d5, long d6, + long d7, long d8, long d9, struct s vs) { + n = vs.m; + ve = vs.v; +} + +/* { dg-final { scan-assembler "li \.\*,144" } } */ +/* { dg-final { scan-assembler "ld \.\*,128\\(1\\)" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57949-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57949-2.c new file mode 100644 index 000000000..39a24d9e4 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr57949-2.c @@ -0,0 +1,20 @@ +/* { dg-do compile { target { powerpc64*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc_elfv2 } { "*" } { "" } } */ +/* { dg-options "-O2 -mcpu=power7" } */ + +/* Verify that vs is not 16-byte aligned in the absence of -mno-compat-align-parm. */ + +typedef float v4sf __attribute__ ((vector_size (16))); +struct s { long m; v4sf v; }; +long n; +v4sf ve; + +void pr57949 (long d1, long d2, long d3, long d4, long d5, long d6, + long d7, long d8, long d9, struct s vs) { + n = vs.m; + ve = vs.v; +} + +/* { dg-final { scan-assembler "ld .\*,136\\(1\\)" } } */ +/* { dg-final { scan-assembler "ld .\*,120\\(1\\)" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr58673-1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr58673-1.c new file mode 100644 index 000000000..6f7838f8d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr58673-1.c @@ -0,0 +1,78 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -m64 -O1" } */ + +enum typecode +{ + QIcode, QUcode, HIcode, HUcode, SIcode, SUcode, DIcode, DUcode, SFcode, + DFcode, XFcode, Pcode, Tcode, LAST_AND_UNUSED_TYPECODE +}; +enum bytecode_opcode +{ + neverneverland, drop, duplicate, over, setstackSI, adjstackSI, constQI, + constHI, constSI, constDI, constSF, constDF, constXF, constP, loadQI, + loadHI, loadSI, loadDI, loadSF, loadDF, loadXF, loadP, storeQI, storeHI, + storeSI, storeDI, storeSF, storeDF, storeXF, storeP, storeBLK, clearBLK, + addconstPSI, newlocalSI, localP, argP, convertQIHI, convertHISI, + convertSIDI, convertQISI, convertQUHU, convertHUSU, convertSUDU, + convertQUSU, convertSFDF, convertDFXF, convertHIQI, convertSIHI, + convertDISI, convertSIQI, convertSUQU, convertDFSF, convertXFDF, + convertSISF, convertSIDF, convertSIXF, convertSUSF, convertSUDF, + convertSUXF, convertDISF, convertDIDF, convertDIXF, convertDUSF, + convertDUDF, convertDUXF, convertSFSI, convertDFSI, convertXFSI, + convertSFSU, convertDFSU, convertXFSU, convertSFDI, convertDFDI, + convertXFDI, convertSFDU, convertDFDU, convertXFDU, convertPSI, + convertSIP, convertSIT, convertDIT, convertSFT, convertDFT, convertXFT, + convertPT, zxloadBI, sxloadBI, sstoreBI, addSI, addDI, addSF, addDF, + addXF, addPSI, subSI, subDI, subSF, subDF, subXF, subPP, mulSI, mulDI, + mulSU, mulDU, mulSF, mulDF, mulXF, divSI, divDI, divSU, divDU, divSF, + divDF, divXF, modSI, modDI, modSU, modDU, andSI, andDI, iorSI, iorDI, + xorSI, xorDI, lshiftSI, lshiftSU, lshiftDI, lshiftDU, rshiftSI, rshiftSU, + rshiftDI, rshiftDU, ltSI, ltSU, ltDI, ltDU, ltSF, ltDF, ltXF, ltP, leSI, + leSU, leDI, leDU, leSF, leDF, leXF, leP, geSI, geSU, geDI, geDU, geSF, + geDF, geXF, geP, gtSI, gtSU, gtDI, gtDU, gtSF, gtDF, gtXF, gtP, eqSI, + eqDI, eqSF, eqDF, eqXF, eqP, neSI, neDI, neSF, neDF, neXF, neP, negSI, + negDI, negSF, negDF, negXF, notSI, notDI, notT, predecQI, predecHI, + predecSI, predecDI, predecP, predecSF, predecDF, predecXF, predecBI, + preincQI, preincHI, preincSI, preincDI, preincP, preincSF, preincDF, + preincXF, preincBI, postdecQI, postdecHI, postdecSI, postdecDI, postdecP, + postdecSF, postdecDF, postdecXF, postdecBI, postincQI, postincHI, + postincSI, postincDI, postincP, postincSF, postincDF, postincXF, + postincBI, xjumpif, xjumpifnot, jump, jumpP, caseSI, caseSU, caseDI, + caseDU, call, returnP, ret, linenote, LAST_AND_UNUSED_OPCODE +}; +struct binary_operator +{ + enum bytecode_opcode opcode; + enum typecode arg0; +}; +static struct conversion_recipe +{ + unsigned char *opcodes; + int cost; +} +conversion_recipe[((int) LAST_AND_UNUSED_TYPECODE)][((int) + LAST_AND_UNUSED_TYPECODE)]; +static struct conversion_recipe +deduce_conversion (from, to) + enum typecode from, to; +{ + (conversion_recipe[(int) from][(int) to]. + opcodes ? 0 : (conversion_recipe[(int) from][(int) to] = + deduce_conversion (from, to), 0)); +} + +void +bc_expand_binary_operation (optab, resulttype, arg0, arg1) + struct binary_operator optab[]; +{ + int i, besti, cost, bestcost; + enum typecode resultcode, arg0code; + for (i = 0; optab[i].opcode != -1; ++i) + { + (conversion_recipe[(int) arg0code][(int) optab[i].arg0]. + opcodes ? 0 : (conversion_recipe[(int) arg0code][(int) optab[i].arg0] = + deduce_conversion (arg0code, optab[i].arg0), 0)); + } +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr58673-2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr58673-2.c new file mode 100644 index 000000000..b70d2eed8 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr58673-2.c @@ -0,0 +1,217 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O3 -m64 -funroll-loops" } */ + +#include <stddef.h> +#include <stdlib.h> +#include <math.h> +#include <string.h> + +typedef long unsigned int size_t; +typedef struct _IO_FILE FILE; +typedef float real; +typedef real rvec[3]; +typedef real matrix[3][3]; +typedef real tensor[3][3]; +enum +{ + F_BONDS, F_G96BONDS, F_MORSE, F_CUBICBONDS, F_CONNBONDS, F_HARMONIC, + F_ANGLES, F_G96ANGLES, F_PDIHS, F_RBDIHS, F_IDIHS, F_LJ14, F_COUL14, F_LJ, + F_BHAM, F_LJLR, F_DISPCORR, F_SR, F_LR, F_WPOL, F_POSRES, F_DISRES, + F_DISRESVIOL, F_ORIRES, F_ORIRESDEV, F_ANGRES, F_ANGRESZ, F_SHAKE, + F_SHAKENC, F_SETTLE, F_DUMMY2, F_DUMMY3, F_DUMMY3FD, F_DUMMY3FAD, + F_DUMMY3OUT, F_DUMMY4FD, F_EQM, F_EPOT, F_EKIN, F_ETOT, F_TEMP, F_PRES, + F_DVDL, F_DVDLKIN, F_NRE +}; +typedef union +{ + struct + { + } + bham; + struct + { + real rA, krA, rB, krB; + } + harmonic; +} +t_iparams; +typedef struct +{ + t_iparams *iparams; +} +t_idef; +typedef struct +{ +} +t_inputrec; +typedef struct +{ +} +t_commrec; +typedef struct +{ +} +t_forcerec; +typedef struct +{ +} +t_mdatoms; +typedef struct +{ +} +t_filenm; +enum +{ + eoPres, eoEpot, eoVir, eoDist, eoMu, eoForce, eoFx, eoFy, eoFz, eoPx, eoPy, + eoPz, eoPolarizability, eoDipole, eoObsNR, eoMemory = + eoObsNR, eoInter, eoUseVirial, eoNR +}; +extern char *eoNames[eoNR]; +typedef struct +{ + int bPrint; +} +t_coupl_LJ; +typedef struct +{ + int eObs; + t_iparams xi; +} +t_coupl_iparams; +typedef struct +{ + real act_value[eoObsNR]; + real av_value[eoObsNR]; + real ref_value[eoObsNR]; + int bObsUsed[eoObsNR]; + int nLJ, nBU, nQ, nIP; + t_coupl_LJ *tcLJ; +} +t_coupl_rec; +static void +pr_ff (t_coupl_rec * tcr, real time, t_idef * idef, t_commrec * cr, int nfile, + t_filenm fnm[]) +{ + static FILE *prop; + static FILE **out = ((void *) 0); + static FILE **qq = ((void *) 0); + static FILE **ip = ((void *) 0); + char buf[256]; + char *leg[] = { + "C12", "C6" + }; + char **raleg; + int i, j, index; + if ((prop == ((void *) 0)) && (out == ((void *) 0)) && (qq == ((void *) 0)) + && (ip == ((void *) 0))) + { + for (i = j = 0; (i < eoObsNR); i++) + { + if (tcr->bObsUsed[i]) + { + raleg[j++] = + (__extension__ + (__builtin_constant_p (eoNames[i]) + && ((size_t) (const void *) ((eoNames[i]) + 1) - + (size_t) (const void *) (eoNames[i]) == + 1) ? (((const char *) (eoNames[i]))[0] == + '\0' ? (char *) calloc ((size_t) 1, + (size_t) 1) : ( + { + size_t + __len + = + strlen + (eoNames + [i]) + + + 1; + char + *__retval + = + (char + *) + malloc + (__len); + __retval;} + )): __strdup (eoNames[i]))); + raleg[j++] = + (__extension__ + (__builtin_constant_p (buf) + && ((size_t) (const void *) ((buf) + 1) - + (size_t) (const void *) (buf) == + 1) ? (((const char *) (buf))[0] == + '\0' ? (char *) calloc ((size_t) 1, + (size_t) 1) : ( + { + size_t + __len + = + strlen + (buf) + + + 1; + char + *__retval + = + (char + *) + malloc + (__len); + __retval;} + )): __strdup (buf))); + } + } + if (tcr->nLJ) + { + for (i = 0; (i < tcr->nLJ); i++) + { + if (tcr->tcLJ[i].bPrint) + { + xvgr_legend (out[i], (sizeof (leg) / sizeof ((leg)[0])), + leg); + } + } + } + } +} + +void +do_coupling (FILE * log, int nfile, t_filenm fnm[], t_coupl_rec * tcr, real t, + int step, real ener[], t_forcerec * fr, t_inputrec * ir, + int bMaster, t_mdatoms * md, t_idef * idef, real mu_aver, + int nmols, t_commrec * cr, matrix box, tensor virial, + tensor pres, rvec mu_tot, rvec x[], rvec f[], int bDoIt) +{ + int i, j, ati, atj, atnr2, type, ftype; + real deviation[eoObsNR], prdev[eoObsNR], epot0, dist, rmsf; + real ff6, ff12, ffa, ffb, ffc, ffq, factor, dt, mu_ind; + int bTest, bPrint; + t_coupl_iparams *tip; + if (bPrint) + { + pr_ff (tcr, t, idef, cr, nfile, fnm); + } + for (i = 0; (i < eoObsNR); i++) + { + deviation[i] = + calc_deviation (tcr->av_value[i], tcr->act_value[i], + tcr->ref_value[i]); + prdev[i] = tcr->ref_value[i] - tcr->act_value[i]; + } + if (bPrint) + pr_dev (tcr, t, prdev, cr, nfile, fnm); + for (i = 0; (i < atnr2); i++) + { + factor = dt * deviation[tip->eObs]; + switch (ftype) + { + case F_BONDS: + if (fabs (tip->xi.harmonic.krA) > 1.2e-38) + idef->iparams[type].harmonic.krA *= + (1 + factor / tip->xi.harmonic.krA); + } + } +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr59054.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr59054.c new file mode 100644 index 000000000..ab2ff6dea --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr59054.c @@ -0,0 +1,9 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-mcpu=power7 -O0 -m64" } */ + +long foo (void) { return 0; } + +/* { dg-final { scan-assembler-not "xxlor" } } */ +/* { dg-final { scan-assembler-not "stfd" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60137.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60137.c new file mode 100644 index 000000000..4777a5382 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60137.c @@ -0,0 +1,17 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O3 -mno-vsx" } */ + +/* target/60137, compiler got a 'could not split insn error'. */ + +extern int target_flags; +extern char fixed_regs[53]; +extern char call_used_regs[53]; + +void init_reg_sets_1(void) +{ + int i; + for (i = 0; i < 53; i++) + fixed_regs[i] = call_used_regs[i] = (call_used_regs[i] &((target_flags & 0x02000000) ? 2 : 1)) != 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60203.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60203.c new file mode 100644 index 000000000..6a4b4fa1d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60203.c @@ -0,0 +1,40 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-options "-mcpu=power8 -O3" } */ + +union u_ld { long double ld; double d[2]; }; + +long double +pack (double a, double aa) +{ + union u_ld u; + u.d[0] = a; + u.d[1] = aa; + return u.ld; +} + +double +unpack_0 (long double x) +{ + union u_ld u; + u.ld = x; + return u.d[0]; +} + +double +unpack_1 (long double x) +{ + union u_ld u; + u.ld = x; + return u.d[1]; +} + +/* { dg-final { scan-assembler-not "stfd" } } */ +/* { dg-final { scan-assembler-not "lfd" } } */ +/* { dg-final { scan-assembler-not "lxsdx" } } */ +/* { dg-final { scan-assembler-not "stxsdx" } } */ +/* { dg-final { scan-assembler-not "mfvsrd" } } */ +/* { dg-final { scan-assembler-not "mtvsrd" } } */ + + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60735.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60735.c new file mode 100644 index 000000000..9bac30b51 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/pr60735.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-mcpu=8548 -mspe -mabi=spe -O2" } */ +/* { dg-skip-if "not an SPE target" { ! powerpc_spe_nocache } { "*" } { "" } } */ + +/* In PR60735, the type _Decimal64 generated an insn not found message. */ + +void +pr60735 (_Decimal64 *p, _Decimal64 *q) +{ + *p = *q; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/quad-atomic.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/quad-atomic.c new file mode 100644 index 000000000..6cf278852 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/quad-atomic.c @@ -0,0 +1,67 @@ +/* { dg-do run { target { powerpc*-*-linux* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-skip-if "" { powerpc*-*-*spe* } { "*" } { "" } } */ +/* { dg-require-effective-target p8vector_hw } */ +/* { dg-options "-mcpu=power8 -O2" } */ + +/* Test whether we get the right bits for quad word atomic instructions. */ +#include <stdlib.h> + +static __int128_t quad_fetch_and (__int128_t *, __int128_t value) __attribute__((__noinline__)); +static __int128_t quad_fetch_or (__int128_t *, __int128_t value) __attribute__((__noinline__)); +static __int128_t quad_fetch_add (__int128_t *, __int128_t value) __attribute__((__noinline__)); + +static __int128_t +quad_fetch_and (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_and (ptr, value, __ATOMIC_ACQUIRE); +} + +static __int128_t +quad_fetch_or (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_or (ptr, value, __ATOMIC_ACQUIRE); +} + +static __int128_t +quad_fetch_add (__int128_t *ptr, __int128_t value) +{ + return __atomic_fetch_add (ptr, value, __ATOMIC_ACQUIRE); +} + +int +main (void) +{ + __int128_t result; + __int128_t value; + __int128_t and_input = ((((__int128_t) 0x1234567890abcdefULL) << 64) | ((__int128_t) 0xfedcba0987654321ULL)); + __int128_t and_value = ((((__int128_t) 0xfffffffffffffff0ULL) << 64) | ((__int128_t) 0xfffffffffffffff0ULL)); + __int128_t and_exp = ((((__int128_t) 0x1234567890abcde0ULL) << 64) | ((__int128_t) 0xfedcba0987654320ULL)); + + __int128_t or_input = ((((__int128_t) 0x1234567890abcdefULL) << 64) | ((__int128_t) 0xfedcba0987654321ULL)); + __int128_t or_value = ((((__int128_t) 0x0000000000000010ULL) << 64) | ((__int128_t) 0x000000000000000eULL)); + __int128_t or_exp = ((((__int128_t) 0x1234567890abcdffULL) << 64) | ((__int128_t) 0xfedcba098765432fULL)); + + __int128_t add_input = ((((__int128_t) 0x1234567890abcdefULL) << 64) | ((__int128_t) 0xfedcba0987654321ULL)); + __int128_t add_value = ((((__int128_t) 0x0000000001000000ULL) << 64) | ((__int128_t) 0x0000001000000000ULL)); + __int128_t add_exp = ((((__int128_t) 0x1234567891abcdefULL) << 64) | ((__int128_t) 0xfedcba1987654321ULL)); + + + value = and_input; + result = quad_fetch_and (&value, and_value); + if (result != and_input || value != and_exp) + abort (); + + value = or_input; + result = quad_fetch_or (&value, or_value); + if (result != or_input || value != or_exp) + abort (); + + value = add_input; + result = quad_fetch_add (&value, add_value); + if (result != add_input || value != add_exp) + abort (); + + return 0; +} + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/rs6000-ldouble-3.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/rs6000-ldouble-3.c new file mode 100644 index 000000000..1c78052e6 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/rs6000-ldouble-3.c @@ -0,0 +1,21 @@ +/* Test accuracy of long double division (glibc bug 15396). */ +/* { dg-do run { target powerpc*-*-linux* powerpc*-*-darwin* powerpc*-*-aix* rs6000-*-* } } */ +/* { dg-options "-mlong-double-128" } */ + +extern void exit (int); +extern void abort (void); + +volatile long double a = 0x1p-1024L; +volatile long double b = 0x3p-53L; +volatile long double r; +volatile long double expected = 0x1.55555555555555555555555555p-973L; + +int +main (void) +{ + r = a / b; + /* Allow error up to 2ulp. */ + if (__builtin_fabsl (r - expected) > 0x1p-1073L) + abort (); + exit (0); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c new file mode 100644 index 000000000..98f7615da --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c @@ -0,0 +1,19 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* powerpc-ibm-aix* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power6 -mhard-dfp" } */ +/* { dg-final { scan-assembler-not "lfiwzx" } } */ +/* { dg-final { scan-assembler-times "lfd" 2 } } */ +/* { dg-final { scan-assembler-times "dctdp" 2 } } */ +/* { dg-final { scan-assembler-times "dadd" 1 } } */ +/* { dg-final { scan-assembler-times "drsp" 1 } } */ + +/* Test that for power6 we need to use a bounce buffer on the stack to load + SDmode variables because the power6 does not have a way to directly load + 32-bit values from memory. */ +_Decimal32 a; + +void inc_dec32 (void) +{ + a += (_Decimal32) 1.0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/sd-vsx.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/sd-vsx.c new file mode 100644 index 000000000..7a3c6d877 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/sd-vsx.c @@ -0,0 +1,20 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* powerpc-ibm-aix* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power7 -mhard-dfp" } */ +/* { dg-final { scan-assembler-times "lfiwzx" 2 } } */ +/* { dg-final { scan-assembler-times "stfiwx" 1 } } */ +/* { dg-final { scan-assembler-not "lfd" } } */ +/* { dg-final { scan-assembler-not "stfd" } } */ +/* { dg-final { scan-assembler-times "dctdp" 2 } } */ +/* { dg-final { scan-assembler-times "dadd" 1 } } */ +/* { dg-final { scan-assembler-times "drsp" 1 } } */ + +/* Test that power7 can directly load/store SDmode variables without using a + bounce buffer. */ +_Decimal32 a; + +void inc_dec32 (void) +{ + a += (_Decimal32) 1.0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ti_math1.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ti_math1.c new file mode 100644 index 000000000..cdf925100 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ti_math1.c @@ -0,0 +1,20 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-options "-O2" } */ +/* { dg-final { scan-assembler-times "addc" 1 } } */ +/* { dg-final { scan-assembler-times "adde" 1 } } */ +/* { dg-final { scan-assembler-times "subfc" 1 } } */ +/* { dg-final { scan-assembler-times "subfe" 1 } } */ +/* { dg-final { scan-assembler-not "subf " } } */ + +__int128 +add_128 (__int128 *ptr, __int128 val) +{ + return (*ptr + val); +} + +__int128 +sub_128 (__int128 *ptr, __int128 val) +{ + return (*ptr - val); +} + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ti_math2.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ti_math2.c new file mode 100644 index 000000000..b9c03300d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/ti_math2.c @@ -0,0 +1,73 @@ +/* { dg-do run { target { powerpc*-*-* && lp64 } } } */ +/* { dg-options "-O2 -fno-inline" } */ + +union U { + __int128 i128; + struct { + long l1; + long l2; + } s; +}; + +union U u1,u2; + +__int128 +create_128 (long most_sig, long least_sig) +{ + union U u; + +#if __LITTLE_ENDIAN__ + u.s.l1 = least_sig; + u.s.l2 = most_sig; +#else + u.s.l1 = most_sig; + u.s.l2 = least_sig; +#endif + return u.i128; +} + +long most_sig (union U * u) +{ +#if __LITTLE_ENDIAN__ + return (*u).s.l2; +#else + return (*u).s.l1; +#endif +} + +long least_sig (union U * u) +{ +#if __LITTLE_ENDIAN__ + return (*u).s.l1; +#else + return (*u).s.l2; +#endif +} + +__int128 +add_128 (__int128 *ptr, __int128 val) +{ + return (*ptr + val); +} + +__int128 +sub_128 (__int128 *ptr, __int128 val) +{ + return (*ptr - val); +} + +int +main (void) +{ + /* Do a simple add/sub to make sure carry is happening between the dwords + and that dwords are in correct endian order. */ + u1.i128 = create_128 (1, -1); + u2.i128 = add_128 (&u1.i128, 1); + if ((most_sig (&u2) != 2) || (least_sig (&u2) != 0)) + __builtin_abort (); + u2.i128 = sub_128 (&u2.i128, 1); + if ((most_sig (&u2) != 1) || (least_sig (&u2) != -1)) + __builtin_abort (); + return 0; +} + diff --git a/gcc-4.8/gcc/testsuite/gcc.target/powerpc/vsx-float0.c b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/vsx-float0.c new file mode 100644 index 000000000..7e4fea689 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/powerpc/vsx-float0.c @@ -0,0 +1,16 @@ +/* { dg-do compile { target { powerpc*-*-* } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-options "-O2 -mcpu=power7" } */ +/* { dg-final { scan-assembler "xxlxor" } } */ + +/* Test that we generate xxlor to clear a SFmode register. */ + +float sum (float *p, unsigned long n) +{ + float sum = 0.0f; /* generate xxlxor instead of load */ + while (n-- > 0) + sum += *p++; + + return sum; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-1.c new file mode 100644 index 000000000..b9d6139b0 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-1.c @@ -0,0 +1,20 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch --save-temps" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "nopr\t%r7" 12 } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-10.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-10.c new file mode 100644 index 000000000..b91b3478e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-10.c @@ -0,0 +1,21 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mno-hotpatch --save-temps" } */ + +#include <stdio.h> + +__attribute__ ((hotpatch(2))) +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "nopr\t%r7" 2 } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-11.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-11.c new file mode 100644 index 000000000..491677342 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-11.c @@ -0,0 +1,20 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch -mno-hotpatch --save-temps" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-not "nopr\t%r7" } } */ +/* { dg-final { scan-assembler-not "nop\t0" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-12.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-12.c new file mode 100644 index 000000000..b3e9427d4 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-12.c @@ -0,0 +1,20 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mno-hotpatch -mhotpatch=1 --save-temps" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "nopr\t%r7" 1 } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-2.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-2.c new file mode 100644 index 000000000..6cc29447d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-2.c @@ -0,0 +1,20 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch=1 --save-temps" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "nopr\t%r7" 1 } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-3.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-3.c new file mode 100644 index 000000000..9f0b2b756 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-3.c @@ -0,0 +1,20 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch=0 --save-temps" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-not "nopr\t%r7" } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-4.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-4.c new file mode 100644 index 000000000..c1dba20a3 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-4.c @@ -0,0 +1,26 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch --save-temps" } */ + +#include <stdio.h> + +inline void hp1(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((always_inline)) +void hp2(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp2' with the 'always_inline' attribute is not hotpatchable" } */ + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-not "nopr\t%r7" } } */ +/* { dg-final { scan-assembler-not "nop\t0" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-5.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-5.c new file mode 100644 index 000000000..ec267d65a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-5.c @@ -0,0 +1,21 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch --save-temps" } */ + +#include <stdio.h> + +__attribute__ ((hotpatch)) +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "nopr\t%r7" 12 } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-6.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-6.c new file mode 100644 index 000000000..5af090d03 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-6.c @@ -0,0 +1,21 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch --save-temps" } */ + +#include <stdio.h> + +__attribute__ ((hotpatch(1))) +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "nopr\t%r7" 1 } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-7.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-7.c new file mode 100644 index 000000000..e73a510b4 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-7.c @@ -0,0 +1,21 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch --save-temps" } */ + +#include <stdio.h> + +__attribute__ ((hotpatch(0))) +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-not "nopr\t%r7" } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-8.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-8.c new file mode 100644 index 000000000..399aa7260 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-8.c @@ -0,0 +1,28 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch --save-temps" } */ + +#include <stdio.h> + +__attribute__ ((hotpatch)) +inline void hp1(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch)) +__attribute__ ((always_inline)) +void hp2(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp2' with the 'always_inline' attribute is not hotpatchable" } */ + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-not "nopr\t%r7" } } */ +/* { dg-final { scan-assembler-not "nop\t0" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-9.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-9.c new file mode 100644 index 000000000..5da675866 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-9.c @@ -0,0 +1,21 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch=1 --save-temps" } */ + +#include <stdio.h> + +__attribute__ ((hotpatch(2))) +void hp1(void) +{ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} + +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "nopr\t%r7" 2 } } */ +/* { dg-final { scan-assembler-times "nop\t0" 1 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-1.c new file mode 100644 index 000000000..45a2cc5dc --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-1.c @@ -0,0 +1,27 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +inline void hp2(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((always_inline)) +void hp3(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp3' with the 'always_inline' attribute is not hotpatchable" } */ + +int main (void) +{ + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-2.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-2.c new file mode 100644 index 000000000..5947f564f --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-2.c @@ -0,0 +1,27 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch=0" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +inline void hp2(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((always_inline)) +void hp3(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp3' with the 'always_inline' attribute is not hotpatchable" } */ + +int main (void) +{ + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-3.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-3.c new file mode 100644 index 000000000..e0c7f6f52 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-3.c @@ -0,0 +1,27 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch=1" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +inline void hp2(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((always_inline)) +void hp3(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp3' with the 'always_inline' attribute is not hotpatchable" } */ + +int main (void) +{ + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-4.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-4.c new file mode 100644 index 000000000..d9f13425a --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-4.c @@ -0,0 +1,11 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do compile } */ +/* { dg-options "-O3 -mzarch -mhotpatch=-1" } */ + +int main (void) +{ + return 0; +} + +/* { dg-excess-errors "argument to '-mhotpatch=' should be a non-negative integer" } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-5.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-5.c new file mode 100644 index 000000000..53f7eac9e --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-5.c @@ -0,0 +1,28 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do compile } */ +/* { dg-options "-O3 -mzarch -mhotpatch=1000000" } */ + +#include <stdio.h> + +void hp1(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch(1000000))) +void hp2(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch(1000001))) +void hp3(void) +{ /* { dg-error "requested 'hotpatch' attribute is not a non-negative integer constant or too large .max. 1000000." } */ + printf("hello, world!\n"); +} + +int main (void) +{ + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-6.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-6.c new file mode 100644 index 000000000..cb10b66f0 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-6.c @@ -0,0 +1,11 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do compile } */ +/* { dg-options "-O3 -mzarch -mhotpatch=1000001" } */ + +int main (void) +{ + return 0; +} + +/* { dg-excess-errors "argument to '-mhotpatch=' is too large .max. 1000000." } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-7.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-7.c new file mode 100644 index 000000000..98ccb42c0 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-7.c @@ -0,0 +1,68 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mno-hotpatch" } */ + +#include <stdio.h> + +__attribute__ ((hotpatch)) +void hp1(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch)) +inline void hp2(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch)) +__attribute__ ((always_inline)) +void hp3(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp3' with the 'always_inline' attribute is not hotpatchable" } */ + +__attribute__ ((hotpatch(0))) +void hp4(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch(0))) +inline void hp5(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch(0))) +__attribute__ ((always_inline)) +void hp6(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp6' with the 'always_inline' attribute is not hotpatchable" } */ + +__attribute__ ((hotpatch(1))) +void hp7(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch(1))) +inline void hp8(void) +{ + printf("hello, world!\n"); +} + +__attribute__ ((hotpatch(1))) +__attribute__ ((always_inline)) +void hp9(void) /* { dg-warning "always_inline function might not be inlinable" } */ +{ + printf("hello, world!\n"); +} /* { dg-warning "function 'hp9' with the 'always_inline' attribute is not hotpatchable" } */ + +int main (void) +{ + return 0; +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-8.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-8.c new file mode 100644 index 000000000..489fc5dd9 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/hotpatch-compile-8.c @@ -0,0 +1,23 @@ +/* Functional tests for the function hotpatching feature. */ + +/* { dg-do run } */ +/* { dg-options "-O3 -mzarch -mhotpatch" } */ + +#include <stdio.h> + +int hp1(void) +{ + int nested1(void) /* { dg-warning "hotpatching is not compatible with nested functions" } */ + { return 1; } + + __attribute__ ((hotpatch)) + int nested2(void) /* { dg-warning "hotpatching is not compatible with nested functions" } */ + { return 1; } + + return nested1() - nested2(); +} + +int main (void) +{ + return hp1(); +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-1.c deleted file mode 100644 index 245ba2c7e..000000000 --- a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-1.c +++ /dev/null @@ -1,73 +0,0 @@ -/* This checks the availability of the low-level builtins introduced - for transactional execution. */ - -/* { dg-do compile } */ -/* { dg-options "-O3 -march=zEC12 -mzarch" } */ - -#include <stdint.h> -#include <htmintrin.h> - -int global = 0; -uint64_t g; -struct __htm_tdb global_tdb; - -int -foo (struct __htm_tdb* tdb, int reg, int *mem, uint64_t *mem64) -{ - - int cc; - int n; - - cc = __builtin_tbegin (0); - cc = __builtin_tbegin (tdb); - cc = __builtin_tbegin (&global_tdb); - - cc = __builtin_tbegin_nofloat (0); - cc = __builtin_tbegin_nofloat (&global_tdb); - - cc = __builtin_tbegin_retry (0, 42); - cc = __builtin_tbegin_retry (0, reg); - cc = __builtin_tbegin_retry (0, *mem); - cc = __builtin_tbegin_retry (0, global); - cc = __builtin_tbegin_retry (tdb, 42); - cc = __builtin_tbegin_retry (&global_tdb, 42); - - cc = __builtin_tbegin_retry_nofloat (0, 42); - cc = __builtin_tbegin_retry_nofloat (0, reg); - cc = __builtin_tbegin_retry_nofloat (0, *mem); - cc = __builtin_tbegin_retry_nofloat (0, global); - cc = __builtin_tbegin_retry_nofloat (&global_tdb, 42); - - __builtin_tbeginc (); - - n = __builtin_tx_nesting_depth(); - - __builtin_non_tx_store(&g, 23); - __builtin_non_tx_store(mem64, 23); - __builtin_non_tx_store(&g, reg); - __builtin_non_tx_store(&g, *mem); - __builtin_non_tx_store(&g, global); - - __builtin_tabort (42 + 255); - __builtin_tabort (reg); - /* { dg-final { scan-assembler-times "tabort\t255" 1 } } */ - __builtin_tabort (reg + 255); - __builtin_tabort (*mem); - __builtin_tabort (global); - /* Here global + 255 gets reloaded into a reg. Better would be to - just reload global or *mem and get the +255 for free as address - arithmetic. */ - __builtin_tabort (*mem + 255); - __builtin_tabort (global + 255); - - __builtin_tend(); - - __builtin_tx_assist (23); - __builtin_tx_assist (reg); - __builtin_tx_assist (*mem); - __builtin_tx_assist (global); -} - -/* Make sure the tdb NULL argument ends up as immediate value in the - instruction. */ -/* { dg-final { scan-assembler-times "tbegin\t0," 10 } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-1.c new file mode 100644 index 000000000..c90490faa --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-1.c @@ -0,0 +1,1073 @@ +/* Functional tests of the htm __builtin_... macros. */ + +/* { dg-do run } */ +/* { dg-require-effective-target htm } */ +/* { dg-options "-O3 -march=zEC12 -mzarch" } */ + +/* ---------------------------- included header files ---------------------- */ + +#include <stdio.h> +#include <string.h> +#include <stdint.h> +#include <htmintrin.h> + +/* ---------------------------- local definitions -------------------------- */ + +#define DEFAULT_MAX_REPETITIONS 5 +#define DEFAULT_REQUIRED_QUORUM ((DEFAULT_MAX_REPETITIONS) - 1) +#define NUM_WARMUP_RUNS 10 + +/* ---------------------------- local macros ------------------------------- */ + +#define TEST_DF_REP(name) \ + { #name, name, DEFAULT_MAX_REPETITIONS, DEFAULT_REQUIRED_QUORUM } +#define TEST_NO_REP(name) { #name, name, 1, 1 } + +/* ---------------------------- local types -------------------------------- */ + +typedef int (*test_func_t)(void); + +typedef struct +{ + const char *name; + test_func_t test_func; + int max_repetitions; + int required_quorum; +} test_table_entry_t; + +/* ---------------------------- local variables ---------------------------- */ + +__attribute__ ((aligned(256))) static struct __htm_tdb local_tdb256; +static struct __htm_tdb local_tdb; +static int do_dump_tdb = 0; + +/* ---------------------------- exported variables (globals) --------------- */ + +__attribute__ ((aligned(256))) struct +{ + float float_1; + float float_2; + float float_3; +} global = { 1.0, 2.5, 0.0 }; + +__attribute__ ((aligned(256))) struct +{ + volatile uint64_t c1; + volatile uint64_t c2; + volatile uint64_t c3; +} counters = { 0, 0, 0 }; + +/* ---------------------------- local helper functions --------------------- */ + +static void dump_tdb (struct __htm_tdb *tdb) +{ + unsigned char *p; + int i; + int j; + + if (do_dump_tdb == 0) + { + return; + } + p = (unsigned char *)tdb; + for (i = 0; i < 16; i++) + { + fprintf (stderr, "0x%02x ", i * 16); + for (j = 0; j < 16; j++) + { + fprintf (stderr, "%02x", (int)p[i * 16 + j]); + if (j < 15) + { + fprintf (stderr, " "); + } + if (j == 7) + { + fprintf (stderr, " "); + } + } + fprintf (stderr, "\n"); + } + + return; +} + +/* ---------------------------- local test functions ----------------------- */ + +/* Check values of the constants defined in htmintrin.h. */ +static int test_constants (void) +{ + if (_HTM_TBEGIN_STARTED != 0) + { + return 100 * _HTM_TBEGIN_STARTED + 1; + } + if (_HTM_TBEGIN_INDETERMINATE != 1) + { + return 100 * _HTM_TBEGIN_INDETERMINATE + 2; + } + if (_HTM_TBEGIN_TRANSIENT != 2) + { + return 100 * _HTM_TBEGIN_TRANSIENT + 3; + } + if (_HTM_TBEGIN_PERSISTENT != 3) + { + return 100 * _HTM_TBEGIN_PERSISTENT + 4; + } + + return 0; +} + +static int test_tbegin_ntstg_tend (void) +{ + int rc; + + counters.c1 = 0; + counters.c2 = 0; + if ((rc = __builtin_tbegin ((void *)0)) == 0) + { + __builtin_non_tx_store ((uint64_t *)&counters.c1, 1); + counters.c2 = 2; + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 5; + } + if (counters.c1 != 1) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 2) + { + return 100 * counters.c2 + 3; + } + } + else + { + return 100 * rc + 4; + } + + return 0; +} + +static int test_tbegin_ntstg_tabort (void) +{ + float f; + + counters.c1 = 0; + counters.c2 = 0; + f = 0; + if (__builtin_tbegin ((void *)0) == 0) + { + __builtin_non_tx_store ((uint64_t *)&counters.c1, 1); + counters.c2 = 2; + f = 1; + __builtin_tabort (256); + return 1; + } + if (counters.c1 != 1) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 0) + { + return 100 * counters.c2 + 3; + } + if (f != 0) + { + return 100 * f + 4; + } + + return 0; +} + +static int test_tbegin_nofloat (void) +{ + int rc; + + counters.c1 = 0; + counters.c2 = 0; + if ((rc = __builtin_tbegin_nofloat ((void *)0)) == 0) + { + __builtin_non_tx_store ((uint64_t *)&counters.c1, 1); + counters.c2 = 2; + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 5; + } + if (counters.c1 != 1) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 2) + { + return 100 * counters.c2 + 3; + } + } + else + { + return 100 * rc + 4; + } + + return 0; +} + +static int test_tbegin_retry (void) +{ + int rc; + + counters.c1 = 0; + counters.c2 = 0; + counters.c3 = 0; + if ((rc = __builtin_tbegin_retry ((void *)0, 5)) == 0) + { + int do_abort; + + do_abort = (counters.c1 == 0) ? 1 : 0; + __builtin_non_tx_store ( + (uint64_t *)&counters.c1, counters.c1 + 1); + if (do_abort == 1) + { + __builtin_tabort (256); + } + counters.c2 = counters.c2 + 10; + __builtin_non_tx_store ((uint64_t *)&counters.c3, 3); + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 5; + } + if (counters.c1 != 2) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 10) + { + return 100 * counters.c2 + 3; + } + if (counters.c3 != 3) + { + return 100 * counters.c3 + 6; + } + } + else + { + return 100 * rc + 4; + } + + return 0; +} + +static int test_tbegin_retry_nofloat (void) +{ + int rc; + + counters.c1 = 0; + counters.c2 = 0; + counters.c3 = 0; + if ((rc = __builtin_tbegin_retry_nofloat ((void *)0, 5)) == 0) + { + int do_abort; + + do_abort = (counters.c1 == 0) ? 1 : 0; + __builtin_non_tx_store ( + (uint64_t *)&counters.c1, counters.c1 + 1); + if (do_abort == 1) + { + __builtin_tabort (256); + } + counters.c2 = counters.c2 + 10; + __builtin_non_tx_store ((uint64_t *)&counters.c3, 3); + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 5; + } + if (counters.c1 != 2) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 10) + { + return 100 * counters.c2 + 3; + } + if (counters.c3 != 3) + { + return 100 * counters.c3 + 6; + } + } + else + { + return 100 * rc + 4; + } + + return 0; +} + +static int test_tbegin_aborts (void) +{ + float f; + int rc; + + f = 77; + if ((rc = __builtin_tbegin ((void *)0)) == 0) + { + f = 88; + __builtin_tabort (256); + return 2; + } + else if (rc != 2) + { + return 3; + } + if (f != 77) + { + return 4; + } + f = 66; + if ((rc = __builtin_tbegin ((void *)0)) == 0) + { + f = 99; + __builtin_tabort (257); + return 5; + } + else if (rc != 3) + { + return 100 * rc + 6; + } + if (f != 66) + { + return 100 * f + 7; + } + if ((rc = __builtin_tbegin ((void *)0)) == 0) + { + global.float_3 = global.float_1 + global.float_2; + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 8; + } + } + else + { + return 100 * rc + 9; + } + if (global.float_3 != global.float_1 + global.float_2) + { + return 100 * rc + 10; + } + + return 0; +} + +static __attribute__((noinline)) void indirect_abort(int abort_code) +{ + __builtin_tabort (abort_code); + + return; +} + +static int test_tbegin_indirect_aborts (void) +{ + float f; + int rc; + + f = 77; + if ((rc = __builtin_tbegin ((void *)0)) == 0) + { + f = 88; + indirect_abort(256); + return 2; + } + else if (rc != 2) + { + return 100 * rc + 3; + } + if (f != 77) + { + return 100 * rc + 4; + } + f = 66; + if ((rc = __builtin_tbegin ((void *)0)) == 0) + { + f = 99; + indirect_abort(257); + return 5; + } + else if (rc != 3) + { + return 100 * rc + 6; + } + if (f != 66) + { + return 100 * f + 7; + } + + return 0; +} + +static int test_tbegin_nofloat_aborts (void) +{ + int rc; + + if ((rc = __builtin_tbegin_nofloat ((void *)0)) == 0) + { + __builtin_tabort (256); + return 2; + } + if ((rc = __builtin_tbegin_nofloat ((void *)0)) == 0) + { + __builtin_tabort (257); + return 1005; + } + else if (rc != 3) + { + return 1000 * rc + 6; + } + + return 0; +} + +static int test_tbegin_nofloat_indirect_aborts (void) +{ + int rc; + + if ((rc = __builtin_tbegin_nofloat ((void *)0)) == 0) + { + indirect_abort (256); + return 2; + } + if ((rc = __builtin_tbegin_nofloat ((void *)0)) == 0) + { + indirect_abort (257); + return 1005; + } + else if (rc != 3) + { + return 1000 * rc + 6; + } + + return 0; +} + +static +int _test_tbegin_retry_aborts (int retries, uint64_t abort_code) +{ + int rc; + + counters.c1 = 0; + if ((rc = __builtin_tbegin_retry ((void *)0, retries)) == 0) + { + __builtin_non_tx_store ((uint64_t *)&counters.c1, counters.c1 + 1); + __builtin_tabort (abort_code); + return 2; + } + else + { + if ((abort_code & 1) == 0) + { + if (rc != 2) + { + return 100 * rc + 2003; + } + else if (counters.c1 != (uint64_t)retries + 1) + { + return 1000 * counters.c1 + 100 * retries + 4; + } + } + else + { + if (rc != 3) + { + return 100 * rc + 3005; + } + else if (counters.c1 != 1) + { + return 1000 * counters.c1 + 100 * retries + 6; + } + } + } + + return 0; +} + +static int test_tbegin_retry_aborts (void) +{ + int rc; + int retries; + + for (retries = 1; retries <= 3; retries++) + { + rc = _test_tbegin_retry_aborts (retries, 256); + if (rc != 0) + { + return 10000 + rc; + } + } + for (retries = 1; retries <= 3; retries++) + { + rc = _test_tbegin_retry_aborts (retries, 257); + if (rc != 0) + { + return 20000 + rc; + } + } + if ((rc = __builtin_tbegin_retry ((void *)0, 5)) == 0) + { + global.float_3 = global.float_1 + global.float_2; + rc = __builtin_tend (); + if (rc != 0) + { + return 30000 + 100 * rc + 6; + } + } + else + { + return 30000 + 100 * rc + 7; + } + + return 0; +} + +static int _test_tbegin_retry_nofloat_aborts (int retries, uint64_t abort_code) +{ + int rc; + + counters.c1 = 0; + if ((rc = __builtin_tbegin_retry_nofloat ((void *)0, retries)) == 0) + { + __builtin_non_tx_store ((uint64_t *)&counters.c1, counters.c1 + 1); + __builtin_tabort (abort_code); + return 2; + } + else + { + if ((abort_code & 1) == 0) + { + if (rc != 2) + { + return 100 * rc + 2003; + } + else if (counters.c1 != (uint64_t)retries + 1) + { + return 1000 * counters.c1 + 100 * retries + 4; + } + } + else + { + if (rc != 3) + { + return 100 * rc + 3005; + } + else if (counters.c1 != 1) + { + return 1000 * counters.c1 + 100 * retries + 6; + } + } + } + + return 0; +} + +static int test_tbegin_retry_nofloat_aborts (void) +{ + int rc; + int retries; + + for (retries = 1; retries <= 3; retries++) + { + rc = _test_tbegin_retry_nofloat_aborts (retries, 256); + if (rc != 0) + { + return 10 * retries + rc; + } + } + for (retries = 1; retries <= 3; retries++) + { + rc = _test_tbegin_retry_nofloat_aborts (retries, 257); + if (rc != 0) + { + return 10000 + 10 * retries + rc; + } + } + + return 0; +} + +static int test_tbegin_tdb (void) +{ + int rc; + + local_tdb.format = 0; + if ((rc = __builtin_tbegin (&local_tdb)) == 0) + { + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 1; + } + if (local_tdb.format != 0) + { + dump_tdb (&local_tdb); + return 100 * local_tdb.format + 2; + } + } + else + { + return 100 * rc + 3; + } + local_tdb.format = 0; + if ((rc = __builtin_tbegin (&local_tdb)) == 0) + { + __builtin_tabort (257); + return 4; + } + else + { + if (rc != 3) + { + return 100 * rc + 5; + } + if (local_tdb.format != 1) + { + dump_tdb (&local_tdb); + return 100 * local_tdb.format + 6; + } + } + local_tdb256.format = 0; + if ((rc = __builtin_tbegin (&local_tdb256)) == 0) + { + rc = __builtin_tend (); + if (rc != 0) + { + return 1100 * rc + 1; + } + if (local_tdb256.format != 0) + { + dump_tdb (&local_tdb256); + return 1100 * local_tdb256.format + 2; + } + } + else + { + return 1100 * rc + 3; + } + local_tdb256.format = 0; + if ((rc = __builtin_tbegin (&local_tdb256)) == 0) + { + __builtin_tabort (257); + return 2004; + } + else + { + if (rc != 3) + { + return 2100 * rc + 5; + } + if (local_tdb256.format != 1) + { + dump_tdb (&local_tdb256); + return 2100 * local_tdb256.format + 6; + } + } + + return 0; +} + +static int test_tbegin_nofloat_tdb (void) +{ + int rc; + + local_tdb.format = 0; + if ((rc = __builtin_tbegin_nofloat (&local_tdb)) == 0) + { + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 1; + } + if (local_tdb.format != 0) + { + dump_tdb (&local_tdb); + return 100 * local_tdb.format + 2; + } + } + else + { + return 3; + } + local_tdb.format = 0; + if ((rc = __builtin_tbegin_nofloat (&local_tdb)) == 0) + { + __builtin_tabort (257); + return 4; + } + else + { + if (rc != 3) + { + return 100 * rc + 5; + } + if (local_tdb.format != 1) + { + dump_tdb (&local_tdb); + return 100 * local_tdb.format + 6; + } + } + local_tdb256.format = 0; + if ((rc = __builtin_tbegin_nofloat (&local_tdb256)) == 0) + { + rc = __builtin_tend (); + if (rc != 0) + { + return 1100 * rc + 1; + } + if (local_tdb256.format != 0) + { + dump_tdb (&local_tdb256); + return 1100 * local_tdb256.format + 2; + } + } + else + { + return 1003; + } + local_tdb256.format = 0; + if ((rc = __builtin_tbegin_nofloat (&local_tdb256)) == 0) + { + __builtin_tabort (257); + return 2004; + } + else + { + if (rc != 3) + { + return 2100 * rc + 5; + } + if (local_tdb256.format != 1) + { + dump_tdb (&local_tdb256); + return 2100 * local_tdb256.format + 6; + } + } + + return 0; +} + +static int test_tbegin_retry_tdb (void) +{ + int rc; + + local_tdb256.format = 0; + if ((rc = __builtin_tbegin_retry (&local_tdb256, 2)) == 0) + { + rc = __builtin_tend (); + if (rc != 0) + { + return 1100 * rc + 1; + } + if (local_tdb256.format != 0) + { + dump_tdb (&local_tdb256); + return 1100 * local_tdb256.format + 2; + } + } + else + { + return 1003; + } + local_tdb256.format = 0; + if ((rc = __builtin_tbegin_retry (&local_tdb256, 2)) == 0) + { + __builtin_tabort (257); + return 2004; + } + else + { + if (rc != 3) + { + return 2100 * rc + 5; + } + if (local_tdb256.format != 1) + { + dump_tdb (&local_tdb256); + return 2100 * local_tdb256.format + 6; + } + } + + return 0; +} + +static int test_tbegin_retry_nofloat_tdb (void) +{ + int rc; + + local_tdb.format = 0; + if ((rc = __builtin_tbegin_retry_nofloat (&local_tdb, 2)) == 0) + { + rc = __builtin_tend (); + if (rc != 0) + { + return 100 * rc + 1; + } + if (local_tdb.format != 0) + { + dump_tdb (&local_tdb); + return 100 * local_tdb.format + 2; + } + } + else + { + return 100 * rc + 3; + } + local_tdb.format = 0; + if ((rc = __builtin_tbegin_retry_nofloat (&local_tdb, 2)) == 0) + { + __builtin_tabort (257); + return 4; + } + else + { + if (rc != 3) + { + return 100 * rc + 5; + } + if (local_tdb.format != 1) + { + dump_tdb (&local_tdb); + return 100 * local_tdb.format + 6; + } + } + local_tdb256.format = 0; + if ((rc = __builtin_tbegin_retry_nofloat (&local_tdb256, 2)) == 0) + { + rc = __builtin_tend (); + if (rc != 0) + { + return 1100 * rc + 1; + } + if (local_tdb256.format != 0) + { + dump_tdb (&local_tdb256); + return 1100 * local_tdb256.format + 2; + } + } + else + { + return 1100 * rc + 3; + } + local_tdb256.format = 0; + if ((rc = __builtin_tbegin_retry_nofloat (&local_tdb256, 2)) == 0) + { + __builtin_tabort (257); + return 2004; + } + else + { + if (rc != 3) + { + return 2100 * rc + 5; + } + if (local_tdb256.format != 1) + { + dump_tdb (&local_tdb256); + return 2100 * local_tdb256.format + 6; + } + } + + return 0; +} + +static int test_etnd (void) +{ + int rc; + + counters.c1 = 0; + counters.c2 = 0; + counters.c3 = 0; + if ((rc = __builtin_tbegin ((void *)0)) == 0) + { + counters.c1 = __builtin_tx_nesting_depth (); + if (__builtin_tbegin ((void *)0) == 0) + { + counters.c2 = __builtin_tx_nesting_depth (); + if (__builtin_tbegin ((void *)0) == 0) + { + counters.c3 = __builtin_tx_nesting_depth (); + __builtin_tend (); + } + __builtin_tend (); + } + __builtin_tend (); + } + else + { + return 100 * rc + 1; + } + if (counters.c1 != 1) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 2) + { + return 100 * counters.c2 + 3; + } + if (counters.c3 != 3) + { + return 100 * counters.c3 + 4; + } + + return 0; +} + +static int test_tbeginc (void) +{ + int rc; + + counters.c1 = 0; + __builtin_tbeginc (); + counters.c1 = 1; + rc = __builtin_tend (); + if (rc != 0) + { + return 10000 * rc + 1; + } + if (counters.c1 != 1) + { + return 100000 * counters.c1 + 3; + } + + return 0; +} + +/* ---------------------------- local testing framework functions ---------- */ + +static int run_one_test (const test_table_entry_t *test_entry) +{ + int do_print_passes; + int succeeded; + int rc; + int i; + + /* Warmup run to get all necessary data and instruction pages into the page + * tables. */ + { + int run; + + do_dump_tdb = 0; + for (run = 0; run < NUM_WARMUP_RUNS; run++) + { + test_entry->test_func (); + } + do_dump_tdb = 1; + } + do_print_passes = ( + test_entry->required_quorum != 1 || + test_entry->max_repetitions != 1); + printf ("RRR RUN %s\n", test_entry->name); + if (do_print_passes == 1) + { + printf ( + " (requires %d successful out of %d runs)\n", + test_entry->required_quorum, + test_entry->max_repetitions); + } + succeeded = 0; + rc = 0; + for (rc = 0, i = 0; i < test_entry->max_repetitions; i++) + { + if (do_print_passes == 1) + { + if (i == 0) + { + printf (" "); + } + else + { + printf (","); + } + } + rc = test_entry->test_func (); + if (rc == 0) + { + if (do_print_passes == 1) + { + printf (" success"); + } + succeeded++; + if (succeeded >= test_entry->required_quorum) + { + break; + } + } + else + { + printf (" failed (rc = %d)", rc); + } + } + if (do_print_passes == 1 || rc != 0) + { + printf ("\n"); + } + if (succeeded >= test_entry->required_quorum) + { + printf ("+++ OK %s\n", test_entry->name); + + return 0; + } + else + { + printf ("--- FAIL %s\n", test_entry->name); + + return (rc != 0) ? rc : -1; + } +} + +static int run_all_tests (const test_table_entry_t *test_table) +{ + const test_table_entry_t *test; + int rc; + + for ( + rc = 0, test = &test_table[0]; + test->test_func != NULL && rc == 0; test++) + { + rc = run_one_test (test); + } + + return rc; +} + +/* ---------------------------- interface functions ------------------------ */ + +int main (void) +{ + const test_table_entry_t test_table[] = { + TEST_NO_REP (test_constants), + TEST_DF_REP (test_tbegin_ntstg_tend), + TEST_DF_REP (test_tbegin_ntstg_tabort), + TEST_DF_REP (test_tbegin_nofloat), + TEST_NO_REP (test_tbegin_retry), + TEST_NO_REP (test_tbegin_retry_nofloat), + TEST_DF_REP (test_tbegin_aborts), + TEST_DF_REP (test_tbegin_indirect_aborts), + TEST_DF_REP (test_tbegin_nofloat_aborts), + TEST_DF_REP (test_tbegin_nofloat_indirect_aborts), + TEST_NO_REP (test_tbegin_retry_aborts), + TEST_NO_REP (test_tbegin_retry_nofloat_aborts), + TEST_DF_REP (test_tbegin_tdb), + TEST_DF_REP (test_tbegin_nofloat_tdb), + TEST_NO_REP (test_tbegin_retry_tdb), + TEST_NO_REP (test_tbegin_retry_nofloat_tdb), + TEST_DF_REP (test_etnd), + TEST_DF_REP (test_tbeginc), + { (void *)0, 0, 0 } + }; + + { + int rc; + + rc = run_all_tests (test_table); + + return rc; + } +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-2.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-2.c new file mode 100644 index 000000000..15b0d12ae --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-2.c @@ -0,0 +1,682 @@ +/* Functional tests of the htm __TM_... macros. */ + +/* { dg-do run } */ +/* { dg-require-effective-target htm } */ +/* { dg-options "-O3 -march=zEC12 -mzarch" } */ + +/* ---------------------------- included header files ---------------------- */ + +#include <stdio.h> +#include <string.h> +#include <inttypes.h> +#include <htmxlintrin.h> + +/* ---------------------------- local definitions -------------------------- */ + +#define DEFAULT_MAX_REPETITIONS 5 +#define DEFAULT_REQUIRED_QUORUM ((DEFAULT_MAX_REPETITIONS) - 1) +#define DEFAULT_ABORT_ADDRESS (0x12345678u) + +/* ---------------------------- local macros ------------------------------- */ + +#define TEST_DF_REP(name) \ + { #name, name, DEFAULT_MAX_REPETITIONS, DEFAULT_REQUIRED_QUORUM } +#define TEST_NO_REP(name) { #name, name, 1, 1 } + +/* ---------------------------- local types -------------------------------- */ + +typedef int (*test_func_t)(void); + +typedef struct +{ + const char *name; + test_func_t test_func; + int max_repetitions; + int required_quorum; +} test_table_entry_t; + +typedef enum +{ + ABORT_T_SYSTEM = 0, + ABORT_T_USER = 1, +} abort_user_t; + +typedef enum +{ + ABORT_T_NONE = 0, + ABORT_T_ILLEGAL, + ABORT_T_FOOTPRINT_EXCEEDED, + ABORT_T_NESTED_TOO_DEEP, + ABORT_T_CONFLICT, + + ABORT_T_INVALID_ABORT_CODE +} abort_t; + +/* ---------------------------- local variables ---------------------------- */ + +__attribute__ ((aligned(256))) static struct __htm_tdb local_tdb256; +static struct __htm_tdb local_tdb; + +static abort_t const abort_classes[] = +{ + ABORT_T_INVALID_ABORT_CODE, + ABORT_T_NONE, + ABORT_T_NONE, + ABORT_T_NONE, + + ABORT_T_ILLEGAL, + ABORT_T_NONE, + ABORT_T_NONE, + ABORT_T_FOOTPRINT_EXCEEDED, + + ABORT_T_FOOTPRINT_EXCEEDED, + ABORT_T_CONFLICT, + ABORT_T_CONFLICT, + ABORT_T_ILLEGAL, + + ABORT_T_NONE, + ABORT_T_NESTED_TOO_DEEP, + ABORT_T_NONE, + ABORT_T_NONE, + + ABORT_T_NONE +}; + +static size_t num_abort_classes = sizeof(abort_classes) / sizeof(abort_t); + +/* ---------------------------- exported variables (globals) --------------- */ + +int global_int = 0; +uint64_t global_u64 = 0; +float global_float_1 = 1.0; +float global_float_2 = 2.5; +float global_float_3 = 0.0; +__attribute__ ((aligned(256))) struct +{ + volatile uint64_t c1; + volatile uint64_t c2; + volatile uint64_t c3; +} counters = { 0, 0, 0 }; + +/* ---------------------------- local helper functions --------------------- */ + +static void dump_tdb(struct __htm_tdb *tdb) +{ + unsigned char *p; + int i; + int j; + + p = (unsigned char *)tdb; + for (i = 0; i < 16; i++) + { + fprintf(stderr, "0x%02x ", i * 16); + for (j = 0; j < 16; j++) + { + fprintf(stderr, "%02x", (int)p[i * 16 + j]); + if (j < 15) + { + fprintf(stderr, " "); + } + if (j == 7) + { + fprintf(stderr, " "); + } + } + fprintf(stderr, "\n"); + } + + return; +} + +static void make_fake_tdb(struct __htm_tdb *tdb) +{ + memset(tdb, 0, sizeof(*tdb)); + tdb->format = 1; + tdb->nesting_depth = 1; + tdb->atia = DEFAULT_ABORT_ADDRESS; + tdb->abort_code = 11; + + return; +} + +static int check_abort_code_in_tdb(struct __htm_tdb *tdb, uint64_t abort_code) +{ + long expect_rc; + long rc; + + if (abort_code != 0) + { + long addr; + + addr = __TM_failure_address(&local_tdb); + if (addr != DEFAULT_ABORT_ADDRESS) + { + return 11; + } + } + { + long long tdb_abort_code; + + tdb_abort_code = __TM_failure_code(tdb); + if ((uint64_t)tdb_abort_code != abort_code) + { + fprintf( + stderr, "tm_ac %" PRIu64 ", ac %" PRIu64 + ", tdb_ac %" PRIu64 "\n", + (uint64_t)tdb_abort_code, abort_code, + (uint64_t)tdb->abort_code); + return 10; + } + } + expect_rc = (abort_code >= 256) ? 1 : 0; + rc = __TM_is_user_abort(tdb); + if (rc != expect_rc) + { + fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc); + return 1; + } + { + unsigned char code; + + code = 0xffu; + rc = __TM_is_named_user_abort(tdb, &code); + if (rc != expect_rc) + { + fprintf( + stderr, "rc %ld, expect_rc %ld\n", rc, + expect_rc); + return 2; + } + if (expect_rc == 1 && code != abort_code - 256) + { + return 3; + } + } + if (abort_code > (uint64_t)num_abort_classes) + { + abort_code = (uint64_t)num_abort_classes; + } + expect_rc = (abort_classes[abort_code] == ABORT_T_ILLEGAL) ? 1 : 0; + rc = __TM_is_illegal(tdb); + if (rc != expect_rc) + { + dump_tdb(tdb); + fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc); + return 4; + } + expect_rc = + (abort_classes[abort_code] == ABORT_T_FOOTPRINT_EXCEEDED) ? + 1 : 0; + rc = __TM_is_footprint_exceeded(tdb); + if (rc != expect_rc) + { + dump_tdb(tdb); + fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc); + return 5; + } + expect_rc = + (abort_classes[abort_code] == ABORT_T_NESTED_TOO_DEEP) ? 1 : 0; + rc = __TM_is_nested_too_deep(tdb); + if (rc != expect_rc) + { + dump_tdb(tdb); + fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc); + return 6; + } + expect_rc = (abort_classes[abort_code] == ABORT_T_CONFLICT) ? 1 : 0; + rc = __TM_is_conflict(tdb); + if (rc != expect_rc) + { + dump_tdb(tdb); + fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc); + return 7; + } + + return 0; +} + +/* ---------------------------- local test functions ----------------------- */ + +/* Not a test; make sure that the involved global cachelines are reserved for + * writing. */ +static int init_cache(void) +{ + make_fake_tdb(&local_tdb); + make_fake_tdb(&local_tdb256); + global_int = 0; + global_u64 = 0; + global_float_1 = 1.0; + global_float_2 = 2.5; + global_float_3 = 0.0; + counters.c1 = 0; + counters.c2 = 0; + counters.c3 = 0; + + return 0; +} + +static int test_abort_classification(void) +{ + int i; + + make_fake_tdb(&local_tdb); + for (i = 0; i <= 256; i++) + { + int rc; + + local_tdb.abort_code = (uint64_t)i; + rc = check_abort_code_in_tdb(&local_tdb, (uint64_t)i); + if (rc != 0) + { + return 100 * i + rc; + } + } + + return 0; +} + +static int test_cc_classification(void) +{ + long rc; + + rc = __TM_is_failure_persistent(0); + if (rc != 0) + { + return 1; + } + rc = __TM_is_failure_persistent(1); + if (rc != 0) + { + return 2; + } + rc = __TM_is_failure_persistent(2); + if (rc != 0) + { + return 3; + } + rc = __TM_is_failure_persistent(3); + if (rc != 1) + { + return 4; + } + + return 0; +} + +static int test_tbegin_ntstg_tend(void) +{ + long rc; + + counters.c1 = 0; + counters.c2 = 0; + if ((rc = __TM_simple_begin()) == 0) + { + __TM_non_transactional_store((uint64_t *)&counters.c1, 1); + counters.c2 = 2; + rc = __TM_end(); + if (rc != 0) + { + return 100 * rc + 5; + } + if (counters.c1 != 1) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 2) + { + return 100 * counters.c2 + 3; + } + } + else + { + return 100 * rc + 4; + } + + return 0; +} + +static int test_tbegin_ntstg_tabort(void) +{ + register float f; + + counters.c1 = 0; + counters.c2 = 0; + f = 0; + if (__TM_simple_begin() == 0) + { + __TM_non_transactional_store((uint64_t *)&counters.c1, 1); + counters.c2 = 2; + f = 1; + __TM_named_abort(0); + return 1; + } + if (counters.c1 != 1) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 0) + { + return 100 * counters.c2 + 3; + } + if (f != 0) + { + return 100 * f + 4; + } + + return 0; +} + +static int test_tbegin_aborts(void) +{ + float f; + long rc; + + f = 77; + if ((rc = __TM_simple_begin()) == 0) + { + f = 88; + __TM_abort(); + return 2; + } + else if (rc != 2) + { + return 3; + } + if (f != 77) + { + return 4; + } + f = 66; + if ((rc = __TM_simple_begin()) == 0) + { + f = 99; + __TM_named_abort(3); + return 5; + } + else if (rc != 3) + { + return 100 * rc + 6; + } + if (f != 66) + { + return 100 * f + 7; + } + if ((rc = __TM_simple_begin()) == 0) + { + global_float_3 = global_float_1 + global_float_2; + rc = __TM_end(); + if (rc != 0) + { + return 100 * rc + 8; + } + } + else + { + return 100 * rc + 9; + } + if (global_float_3 != global_float_1 + global_float_2) + { + return 100 * rc + 10; + } + + return 0; +} + +static int test_tbegin_tdb(void) +{ + long rc; + + local_tdb.format = 0; + if ((rc = __TM_begin(&local_tdb)) == 0) + { + rc = __TM_end(); + if (rc != 0) + { + return 100 * rc + 1; + } + if (local_tdb.format != 0) + { + dump_tdb(&local_tdb); + return 100 * local_tdb.format + 2; + } + } + else + { + return 100 * rc + 3; + } + local_tdb.format = 0; + if ((rc = __TM_begin(&local_tdb)) == 0) + { + __TM_named_abort(1); + return 4; + } + else + { + if (rc != 3) + { + return 100 * rc + 5; + } + if (local_tdb.format != 1) + { + dump_tdb(&local_tdb); + return 100 * local_tdb.format + 6; + } + } + local_tdb256.format = 0; + if ((rc = __TM_begin(&local_tdb256)) == 0) + { + rc = __TM_end(); + if (rc != 0) + { + return 1100 * rc + 1; + } + if (local_tdb256.format != 0) + { + dump_tdb(&local_tdb256); + return 1100 * local_tdb256.format + 2; + } + } + else + { + return 1100 * rc + 3; + } +#if 1 /*!!!does not work*/ + local_tdb256.format = 0; + if ((rc = __TM_begin(&local_tdb256)) == 0) + { + __TM_named_abort(1); + return 2004; + } + else + { + if (rc != 3) + { + return 2100 * rc + 5; + } + if (local_tdb256.format != 1) + { + dump_tdb(&local_tdb256); + return 2100 * local_tdb256.format + 6; + } + } +#endif + + return 0; +} + +static int test_etnd(void) +{ + long rc; + + { + long nd; + + make_fake_tdb(&local_tdb); + local_tdb.nesting_depth = 0; + nd = __TM_nesting_depth(&local_tdb); + if (nd != 0) + { + return 1; + } + local_tdb.nesting_depth = 7; + nd = __TM_nesting_depth(&local_tdb); + if (nd != 7) + { + return 7; + } + local_tdb.format = 0; + nd = __TM_nesting_depth(&local_tdb); + if (nd != 0) + { + return 2; + } + } + counters.c1 = 0; + counters.c1 = 0; + counters.c2 = 0; + counters.c3 = 0; + if ((rc = __TM_simple_begin()) == 0) + { + counters.c1 = __TM_nesting_depth(0); + if (__TM_simple_begin() == 0) + { + counters.c2 = __TM_nesting_depth(0); + if (__TM_simple_begin() == 0) + { + counters.c3 = __TM_nesting_depth(0); + __TM_end(); + } + __TM_end(); + } + __TM_end(); + } + else + { + return 100 * rc + 1; + } + if (counters.c1 != 1) + { + return 100 * counters.c1 + 2; + } + if (counters.c2 != 2) + { + return 100 * counters.c2 + 3; + } + if (counters.c3 != 3) + { + return 100 * counters.c3 + 4; + } + + return 0; +} + +/* ---------------------------- local testing framework functions ---------- */ + +static int run_one_test(const test_table_entry_t *test_entry) +{ + int do_print_passes; + int succeeded; + int rc; + int i; + + do_print_passes = ( + test_entry->required_quorum != 1 || + test_entry->max_repetitions != 1); + printf("RRR RUN %s\n", test_entry->name); + if (do_print_passes == 1) + { + printf( + " (requires %d successful out of %d runs)\n", + test_entry->required_quorum, + test_entry->max_repetitions); + } + succeeded = 0; + rc = 0; + for (rc = 0, i = 0; i < test_entry->max_repetitions; i++) + { + if (do_print_passes == 1) + { + if (i == 0) + { + printf(" "); + } + else + { + printf(","); + } + } + rc = test_entry->test_func(); + if (rc == 0) + { + if (do_print_passes == 1) + { + printf(" success"); + } + succeeded++; + if (succeeded >= test_entry->required_quorum) + { + break; + } + } + else + { + printf(" failed (rc = %d)", rc); + } + } + if (do_print_passes == 1 || rc != 0) + { + printf("\n"); + } + if (succeeded >= test_entry->required_quorum) + { + printf("+++ OK %s\n", test_entry->name); + + return 0; + } + else + { + printf("--- FAIL %s\n", test_entry->name); + + return (rc != 0) ? rc : -1; + } +} + +static int run_all_tests(const test_table_entry_t *test_table) +{ + const test_table_entry_t *test; + int rc; + + for ( + rc = 0, test = &test_table[0]; + test->test_func != NULL && rc == 0; test++) + { + rc = run_one_test(test); + } + + return rc; +} + +/* ---------------------------- interface functions ------------------------ */ + +int main(void) +{ + const test_table_entry_t test_table[] = { + TEST_NO_REP(init_cache), + TEST_NO_REP(test_abort_classification), + TEST_NO_REP(test_cc_classification), + TEST_DF_REP(test_tbegin_ntstg_tend), + TEST_DF_REP(test_tbegin_ntstg_tabort), + TEST_DF_REP(test_tbegin_aborts), + TEST_DF_REP(test_tbegin_tdb), + TEST_DF_REP(test_etnd), + { (void *)0, 0, 0 } + }; + + { + int rc; + + rc = run_all_tests(test_table); + + return rc; + } +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-1.c new file mode 100644 index 000000000..982a7483d --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-1.c @@ -0,0 +1,164 @@ +/* This checks the availability of the low-level builtins introduced + for transactional execution. */ + +/* { dg-do compile } */ +/* { dg-options "-O3 -march=zEC12 -mzarch" } */ + +#include <stdint.h> +#include <htmintrin.h> + +int global = 0; +uint64_t g; +struct __htm_tdb global_tdb; + +int +foo (struct __htm_tdb* tdb, int reg, int *mem, uint64_t *mem64) +{ + + int cc; + int n; + + __builtin_tbegin ((void *)0); + __builtin_tbegin ((void *)-99999); + __builtin_tbegin ((void *)99999); + while (__builtin_tbegin ((void *)0) != 0) + { + } + cc = __builtin_tbegin ((void *)0x12345678); + cc = __builtin_tbegin (tdb); + cc = __builtin_tbegin (&global_tdb); + cc = __builtin_tbegin ((void *)(long)(reg + 0x12345678)); + cc = __builtin_tbegin ((void *)(long)(reg)); + + __builtin_tbegin_nofloat ((void *)0); + __builtin_tbegin_nofloat ((void *)-99999); + __builtin_tbegin_nofloat ((void *)99999); + cc = __builtin_tbegin_nofloat ((void *)0x12345678); + cc = __builtin_tbegin_nofloat (tdb); + cc = __builtin_tbegin_nofloat (&global_tdb); + cc = __builtin_tbegin_nofloat ((void *)(long)(reg + 0x12345678)); + cc = __builtin_tbegin_nofloat ((void *)(long)(reg)); + + __builtin_tbegin_retry ((void *)0, 0); + cc = __builtin_tbegin_retry ((void *)0, 1); + cc = __builtin_tbegin_retry ((void *)0, -1); + cc = __builtin_tbegin_retry ((void *)0, 42); + cc = __builtin_tbegin_retry ((void *)0, reg); + cc = __builtin_tbegin_retry ((void *)0, *mem); + cc = __builtin_tbegin_retry ((void *)0, global); + cc = __builtin_tbegin_retry (tdb, 42); + cc = __builtin_tbegin_retry (&global_tdb, 42); + cc = __builtin_tbegin_retry ((void *)0x12345678, global); + cc = __builtin_tbegin_retry ( + (void *)(long) (reg + 0x12345678), global + 1); + cc = __builtin_tbegin_retry ( + (void *)(long)(reg), global - 1); + + __builtin_tbegin_retry_nofloat ((void *)0, 0); + cc = __builtin_tbegin_retry_nofloat ((void *)0, 1); + cc = __builtin_tbegin_retry_nofloat ((void *)0, -1); + cc = __builtin_tbegin_retry_nofloat ((void *)0, 42); + cc = __builtin_tbegin_retry_nofloat ((void *)0, reg); + cc = __builtin_tbegin_retry_nofloat ((void *)0, *mem); + cc = __builtin_tbegin_retry_nofloat ((void *)0, global); + cc = __builtin_tbegin_retry_nofloat (tdb, 42); + cc = __builtin_tbegin_retry_nofloat (&global_tdb, 42); + cc = __builtin_tbegin_retry_nofloat ((void *)0x12345678, global); + cc = __builtin_tbegin_retry_nofloat ( + (void *)(long) (reg + 0x12345678), global + 1); + cc = __builtin_tbegin_retry_nofloat ( + (void *)(long)(reg), global - 1); + + __builtin_tbeginc (); + + __builtin_tx_nesting_depth (); + n = __builtin_tx_nesting_depth (); + + __builtin_non_tx_store (mem64, 0); + { + const uint64_t val_var = 0x1122334455667788; + + __builtin_non_tx_store (mem64, val_var); + } + __builtin_non_tx_store (mem64, (uint64_t)reg); + __builtin_non_tx_store (mem64, g); + __builtin_non_tx_store ((uint64_t *)0, 0); + __builtin_non_tx_store ((uint64_t *)0x12345678, 0); + __builtin_non_tx_store (&g, 23); + __builtin_non_tx_store (&g, reg); + __builtin_non_tx_store (&g, *mem); + __builtin_non_tx_store (&g, global); + + __builtin_tend(); + + __builtin_tx_assist (0); + __builtin_tx_assist (1); + __builtin_tx_assist (reg); + __builtin_tx_assist (*mem); + __builtin_tx_assist (global); +} + +/* The taborts must go into separate function since they are + "noreturn". */ + +void +tabort1 () +{ + __builtin_tabort (256); +} + +void +tabort2 (int reg) +{ + __builtin_tabort (reg); +} + +void +tabort3 (int reg) +{ + /* { dg-final { scan-assembler-times "tabort\t255" 1 } } */ + __builtin_tabort (reg + 255); +} + +void +tabort4 (int *mem) +{ + __builtin_tabort (*mem); +} + +void +tabort5 () +{ + __builtin_tabort (global); +} + +void +tabort6 (int *mem) +{ + /* Here global + 255 gets reloaded into a reg. Better would be to + just reload global or *mem and get the +255 for free as address + arithmetic. */ + __builtin_tabort (*mem + 255); +} + +void +tabort7 () +{ + __builtin_tabort (global + 255); +} + +void +tabort8 () +{ + __builtin_tabort (-1); +} + + +/* Make sure the tdb NULL argument ends up as immediate value in the + instruction. */ +/* { dg-final { scan-assembler-times "tbegin\t0," 17 } } */ +/* { dg-final { scan-assembler-times "tbegin\t" 41 } } */ +/* Check number of occurences of certain instructions. */ +/* { dg-final { scan-assembler-times "tbeginc\t" 1 } } */ +/* { dg-final { scan-assembler-times "tabort\t" 8 } } */ +/* { dg-final { scan-assembler "ppa\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-2.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-2.c new file mode 100644 index 000000000..67d76a6d3 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-2.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=zEC12 -mzarch" } */ + +void must_not_compile1 (void) +{ + __builtin_tabort (0); /* { dg-error "Invalid transaction abort code:" } */ +} + +void must_not_compile2 (void) +{ + __builtin_tabort (255); /* { dg-error "Invalid transaction abort code:" } */ +} diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-xl-intrin-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-3.c index 77ceeb770..77ceeb770 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-xl-intrin-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-builtins-compile-3.c diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-1.c index df7e2bac8..6022efb97 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-1.c +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-1.c @@ -1,12 +1,50 @@ -/* { dg-do compile } */ -/* { dg-options "-O3 -march=zEC12 -mzarch" } */ +/* { dg-do run } */ +/* { dg-require-effective-target htm } */ +/* { dg-options "-O3 -march=zEC12 -mzarch --save-temps" } */ -int -foo () +/* __builtin_tbegin has to emit clobbers for all FPRs since the tbegin + instruction does not automatically preserves them. If the + transaction body is fully contained in a function the backend tries + after reload to get rid of the FPR save/restore operations + triggered by the clobbers. This testcase failed since the backend + was able to get rid of all FPR saves/restores and since these were + the only stack operations also of the entire stack space. So even + the save/restore of the stack pointer was omitted in the end. + However, since the frame layout has been fixed before, the prologue + still generated the stack pointer decrement making foo return with + a modified stack pointer. */ + +void abort(void); + +void __attribute__((noinline)) +foo (int a) +{ + if (__builtin_tbegin (0) == 0) + __builtin_tend (); +} + +#ifdef __s390x__ +#define GET_STACK_POINTER(SP) \ + asm volatile ("stg %%r15, %0" : "=QRST" (SP)); +#else +#define GET_STACK_POINTER(SP) \ + asm volatile ("st %%r15, %0" : "=QR" (SP)); +#endif + +int main(void) { - __builtin_tbegin_nofloat (0); - __builtin_tbegin_retry_nofloat (0, 42); + unsigned long new_sp, old_sp; + + GET_STACK_POINTER (old_sp); + foo(42); + GET_STACK_POINTER (new_sp); + + if (old_sp != new_sp) + abort (); + + return 0; } + /* Make sure no FPR saves/restores are emitted. */ -/* { dg-final { scan-assembler-not "std" } } */ -/* { dg-final { scan-assembler-not "ld" } } */ +/* { dg-final { scan-assembler-not "\tstd\t" } } */ +/* { dg-final { scan-assembler-not "\tld\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-2.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-2.c deleted file mode 100644 index 59621a4c1..000000000 --- a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-2.c +++ /dev/null @@ -1,55 +0,0 @@ -/* { dg-do run } */ -/* { dg-options "-O3 -mhtm -Wa,-march=zEC12,-mzarch --save-temps" } */ - -/* __builtin_tbegin has to emit clobbers for all FPRs since the tbegin - instruction does not automatically preserves them. If the - transaction body is fully contained in a function the backend tries - after reload to get rid of the FPR save/restore operations - triggered by the clobbers. This testcase failed since the backend - was able to get rid of all FPR saves/restores and since these were - the only stack operations also of the entire stack space. So even - the save/restore of the stack pointer was omitted in the end. - However, since the frame layout has been fixed before, the prologue - still generated the stack pointer decrement making foo return with - a modified stack pointer. */ - -void abort(void); - -void __attribute__((noinline)) -foo (int a) -{ - /* This is just to prevent the tbegin code from actually being - executed. That way the test may even run on machines prior to - zEC12. */ - if (a == 42) - return; - - if (__builtin_tbegin (0) == 0) - __builtin_tend (); -} - -#ifdef __s390x__ -#define GET_STACK_POINTER(SP) \ - asm volatile ("stg %%r15, %0" : "=QRST" (SP)); -#else -#define GET_STACK_POINTER(SP) \ - asm volatile ("st %%r15, %0" : "=QR" (SP)); -#endif - -int main(void) -{ - unsigned long new_sp, old_sp; - - GET_STACK_POINTER (old_sp); - foo(42); - GET_STACK_POINTER (new_sp); - - if (old_sp != new_sp) - abort (); - - return 0; -} - -/* Make sure no FPR saves/restores are emitted. */ -/* { dg-final { scan-assembler-not "\tstd\t" } } */ -/* { dg-final { scan-assembler-not "\tld\t" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-compile-1.c b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-compile-1.c new file mode 100644 index 000000000..df7e2bac8 --- /dev/null +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/htm-nofloat-compile-1.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=zEC12 -mzarch" } */ + +int +foo () +{ + __builtin_tbegin_nofloat (0); + __builtin_tbegin_retry_nofloat (0, 42); +} +/* Make sure no FPR saves/restores are emitted. */ +/* { dg-final { scan-assembler-not "std" } } */ +/* { dg-final { scan-assembler-not "ld" } } */ diff --git a/gcc-4.8/gcc/testsuite/gcc.target/s390/s390.exp b/gcc-4.8/gcc/testsuite/gcc.target/s390/s390.exp index a4a6609cb..141c0eef2 100644 --- a/gcc-4.8/gcc/testsuite/gcc.target/s390/s390.exp +++ b/gcc-4.8/gcc/testsuite/gcc.target/s390/s390.exp @@ -24,6 +24,19 @@ if ![istarget s390*-*-*] then { # Load support procs. load_lib gcc-dg.exp +# Return 1 if htm (etnd - extract nesting depth) instructions are +# understood by the assembler and can be executed. +proc check_effective_target_htm { } { + if { ![check_runtime s390_check_htm [subst { + int main (void) + { + unsigned int nd; + asm ("etnd %0" : "=d" (nd)); + return nd; + } + }] "-march=zEC12 -mzarch" ] } { return 0 } else { return 1 } +} + # If a testcase doesn't have special options, use these. global DEFAULT_CFLAGS if ![info exists DEFAULT_CFLAGS] then { |