diff options
Diffstat (limited to 'gcc/testsuite/g++.dg')
62 files changed, 2585 insertions, 0 deletions
diff --git a/gcc/testsuite/g++.dg/align-test-1.C b/gcc/testsuite/g++.dg/align-test-1.C new file mode 100644 index 00000000000..e0cdb68c851 --- /dev/null +++ b/gcc/testsuite/g++.dg/align-test-1.C @@ -0,0 +1,295 @@ +/* APPLE LOCAL file Macintosh alignment */ + +/* { dg-do run } */ +/* { dg-options "-Wno-long-long -Wno-invalid-offsetof" } */ + +/* + * Macintosh compiler alignment test for C++. + * Fred Forsman + * Apple Computer, Inc. + */ + +#include <stdio.h> +#include <stddef.h> +#include <string.h> + +extern "C" void abort (void); + +#define Q(x) #x, x + +typedef unsigned char UINT8; +typedef unsigned short UINT16; +typedef unsigned long UINT32; + +static int bad_option = 0; +static int flag_verbose = 0; +static int nbr_failures = 0; + +/* === classes === */ + +class C1 { + static const int f1 = 1; + UINT8 f2; +}; + +class C2 { + static int f1; + UINT8 f2; +}; + +class C3 { + public: + enum E1 { + f1 = 1 + }; + protected: + UINT8 f2; +}; + +class C4 { + UINT8 f1; + static const int f2 = 1; +}; + +class C5 { + UINT8 f2; + static int f1; +}; + +class C6 { + UINT8 f1; + enum E1 { + f2 = 1 + }; +}; + +class C7 { + /* empty base class */ +}; + +#ifndef __LP64__ +#pragma options align=mac68k + +class C8 { + /* empty base class */ +}; + +class C9: public C8 { + public: + UINT8 f1; +}; + +#pragma options align=reset +#endif /* n __LP64 __ */ + +/* What is offset of first field after an empty base class? */ +class C10: public C7 { + public: + UINT8 f1; +}; + +/* Check that we no longer try to put derived class bits in padding at end of base class. */ +class C11 { + public: + UINT32 f1; + UINT8 f2; +}; + +class C12: public C11 { + public: + UINT8 f3; +}; + +/* Check whether compiler will reorder members to take advantage of + padding. If the compiler did this (which it does not appear to + do), f3 and f4 in C14 would be reordered to take advantage of the + padding at the end of the base class. */ +class C13 { + public: + UINT32 f1; + UINT16 f2; +}; + +class C14: public C13 { + public: + UINT32 f3; + UINT16 f4; +}; + +/* Tests for double aligned base class */ + +class C15 { + public: + double f1; + long f2; +}; + +class C16: public C15 { +}; + +class C17: public C15 { + public: + long f3; +}; + +class C18: public C16 { + public: + char f3; +}; + +class C19: public C17 { + public: + char f4; +}; + +/* Tests for alignment in class with v-table pointer */ + +class C20 { + public: + double f1; + virtual void func1(void); +}; + +/* === vectors === */ + +#ifdef __VEC__ +class VC1 { + public: + vector signed short f1; + UINT8 f2; +}; + +typedef struct VS1 { + VC1 f1; + UINT8 f2; +} VS1; + +class VC2: public VC1 { + public: + UINT8 f1; +}; + +typedef struct VS2 { + UINT8 f1; + VC2 f2; + UINT8 f3; +} VS2; + +class VC3 { + public: + vector signed short f1; + virtual void func1(void); +}; + +#endif + +/* === bools === */ + +typedef struct B1 { + bool f1; + UINT8 f2; +} B1; + +typedef struct B2 { + UINT8 f1; + bool f2; +} B2; + + +static void check(char * rec_name, int actual, int expected32, int expected64, + int expected_ia32, char * comment) +{ + int expected; +#ifdef __i386__ + expected = expected_ia32; +#else + expected = ((sizeof(char *) == 8) ? expected64 : expected32); +#endif + if (flag_verbose || (actual != expected)) { + printf("%-20s = %2d (%2d) ", rec_name, actual, expected); + if (actual != expected) { + printf("*** FAIL"); + nbr_failures++; + } else + printf(" PASS"); + printf(": %s\n", comment); + } +} + +static void check_option(char *option) +{ + if (*option == '-') { + if (strcmp(option, "-v") == 0) + flag_verbose = 1; + else { + fprintf(stderr, "*** unrecognized option '%s'.\n", option); + bad_option = 1; + } + } else { + fprintf(stderr, "*** unrecognized option '%s'.\n", option); + bad_option = 1; + } +} + +int main(int argc, char *argv[]) +{ + int i; + + for (i = 1; i < argc; i++) + check_option(argv[i]); + + if (bad_option) + return 1; + + check(Q(sizeof(C1)), 1, 1, 1, "const as 1st field"); + check(Q(sizeof(C2)), 1, 1, 1, "static as 1st field"); + check(Q(sizeof(C3)), 1, 1, 1, "enum as 1st field"); + check(Q(sizeof(C4)), 1, 1, 1, "const as 2nd field"); + check(Q(sizeof(C5)), 1, 1, 1, "static as 2nd field"); + check(Q(sizeof(C6)), 1, 1, 1, "enum as 2nd field"); + check(Q(sizeof(C7)), 1, 1, 1, "empty class, power mode"); +#ifndef __LP64__ + check(Q(sizeof(C8)), 2, 2, 2, "empty class, mac68k mode"); + check(Q(sizeof(C9)), 2, 2, 2, "class with empty base class and one char, mac68k"); + check(Q(offsetof(C9, f1)), 0, 0, 0, "offset of 1st field after empty base class"); +#endif + check(Q(sizeof(C10)), 1, 1, 1, "class based on an empty class, power mode"); + check(Q(sizeof(C11)), 8, 16, 8, "class with long, char"); + check(Q(sizeof(C12)), 12, 24, 12, "class with base class with long, char and its own char"); + check(Q(offsetof(C12, f3)), 8, 16, 8, "offset of 1st field in class with a base class with a long, char"); + check(Q(sizeof(C13)), 8, 16, 8, "class with long, short"); + check(Q(sizeof(C14)), 16, 32, 16, "derived class with short, long"); + check(Q(offsetof(C14, f3)), 8, 16, 8, "offset of 1st field after base class with padding"); + check(Q(offsetof(C14, f4)), 12, 24, 12, "offset of 2nd field after base class with padding"); + + check(Q(sizeof(C15)), 16, 16, 12, "base class with double, long"); + check(Q(sizeof(C16)), 16, 16, 12, "empty derived class with base with double, long"); + check(Q(sizeof(C17)), 24, 24, 16, "derived class with base with double, long and its own long"); + check(Q(sizeof(C18)), 20, 24, 16, "derived class based on empty derived class with base with double, long"); + check(Q(sizeof(C19)), 24, 32, 20, "derived class based on derived class with base with double, long and its own long"); + check(Q(sizeof(C20)), 12, 16, 12, "class with double and v-table ptr"); + check(Q(offsetof(C20, f1)), 4, 8, 4, "offset of double 1st field in class with v-table ptr"); + + /* Vector tests */ +#ifdef __VEC__ + check(Q(sizeof(VC1)), 32, 32, 32, "class with vector as 1st field"); + check(Q(sizeof(VS1)), 48, 48, 48, "struct with a class with a vector as 1st field"); + check(Q(sizeof(VC2)), 48, 48, 48, "class with base class containing a vector"); + check(Q(offsetof(VC2, f1)), 32, 32, 32, "offset of 1st field after base class with vector, char, and padding"); + check(Q(sizeof(VS2)), 80, 80, 80, "struct with a char, class with a vector, char"); + check(Q(offsetof(VS2, f2)), 16, 16, 16, "offset of class with a vector in a struct with char, class..."); + check(Q(offsetof(VS2, f3)), 64, 64, 64, "offset of 2nd char in a struct with char, class, char"); + check(Q(sizeof(VC3)), 32, 32, 32, "class with a vector and v-table ptr"); + check(Q(offsetof(VC3, f1)), 16, 16, 16, "offset vector in class with a vector and v-table ptr"); +#endif + + /* bool tests */ + check(Q(sizeof(bool)), 4, 1, 1, "bool data type"); + check(Q(sizeof(B1)), 8, 2, 2, "struct with bool, char"); + check(Q(sizeof(B2)), 8, 2, 2, "struct with char, bool"); + + if (nbr_failures > 0) + return 1; + else + return 0; +} diff --git a/gcc/testsuite/g++.dg/altivec-1.C b/gcc/testsuite/g++.dg/altivec-1.C new file mode 100644 index 00000000000..6bda7094db0 --- /dev/null +++ b/gcc/testsuite/g++.dg/altivec-1.C @@ -0,0 +1,12 @@ +/* APPLE LOCAL file AltiVec */ +/* Test for static_cast<...> among AltiVec types. */ +/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-options "-faltivec" } */ + +struct Foo2 { + vector unsigned int vui; + vector signed int As_vsi() { + return static_cast<vector signed int>(vui); /* { dg-bogus "invalid static_cast" } */ + } +}; + diff --git a/gcc/testsuite/g++.dg/altivec-2.C b/gcc/testsuite/g++.dg/altivec-2.C new file mode 100644 index 00000000000..0b2f3751a24 --- /dev/null +++ b/gcc/testsuite/g++.dg/altivec-2.C @@ -0,0 +1,15 @@ +/* APPLE LOCAL file AltiVec */ +/* Test for distinguishing 'vector bool ...' from 'vector unsigned ...' + types by the front-end. */ +/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-options "-faltivec" } */ + +struct Foo1 { + void foo(vector unsigned char) { } + void foo(vector bool char) { } /* { dg-bogus "has already been declared" } */ + void bar(vector unsigned short) { } + void bar(vector bool short) { } /* { dg-bogus "has already been declared" } */ + void baz(vector unsigned int) { } + void baz(vector bool int) { } /* { dg-bogus "has already been declared" } */ +}; + diff --git a/gcc/testsuite/g++.dg/altivec-3.C b/gcc/testsuite/g++.dg/altivec-3.C new file mode 100644 index 00000000000..77084a1d824 --- /dev/null +++ b/gcc/testsuite/g++.dg/altivec-3.C @@ -0,0 +1,21 @@ +/* APPLE LOCAL file AltiVec */ +/* { dg-do run { target powerpc*-*-* } } */ +/* { dg-options "-faltivec -Wall" } */ + +/* This test checks if AltiVec builtins accept const-qualified + arguments. */ + +int main (int argc, const char * argv[]) +{ + int i; + const float cf = 1.0; + vector float v; + const vector float cv = (vector float)(1.0, 2.0, 3.0, 4.0); + + vec_dst(&cv, i, 0); + v = vec_ld(0, &cv); + v = vec_lde(0, &cf); + vec_lvsl(0, &cf); + + return 0; +} diff --git a/gcc/testsuite/g++.dg/altivec-4.C b/gcc/testsuite/g++.dg/altivec-4.C new file mode 100644 index 00000000000..63eb1d5c379 --- /dev/null +++ b/gcc/testsuite/g++.dg/altivec-4.C @@ -0,0 +1,129 @@ +/* APPLE LOCAL file AltiVec */ +/* { dg-do run { target powerpc*-*-* } } */ +/* { dg-options "-faltivec -maltivec" } */ + +/* Test for correct handling of AltiVec constants passed + through '...' (va_arg). */ + +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> + +#define CHECK_INVARIANT(expr) \ + if (!(expr)) { \ + printf ("ASSERT FAILED: %d: %s\n", __LINE__, #expr); \ + abort (); \ + } + +struct foo { int x; int y; }; +struct vfoo { int x; __vector signed int v; int y; }; +union u { __vector signed int v; signed int i[4]; }; + +struct foo x_g = { 3, 4}; +struct vfoo vx_g = { 10, (vector signed int)(11, 12, 13, 14), 15 }; +__vector signed int v_g = (vector signed int) (22, 23, 24, 25); +struct vfoo vx2_g = { 30, (vector signed int)(31, 32, 33, 34), 35 }; +__vector signed int v2_g = (vector signed int)(40, 41, 42, 43); +int i_1 = 99, i_2 = 33; +double d_2 = 1.5, d_3 = 1.75; +long double ld_1 = 1.25; + +void bar (int i, ... ) +{ + struct foo xi; + double d; + long double ld; + float f; + char c; + short s; + va_list ap; + va_start(ap, i); + xi = va_arg(ap, struct foo); + s = (short)va_arg(ap, int); + f = (float)va_arg(ap, double); + ld = va_arg(ap, long double); + c = (char)va_arg(ap, int); + d = va_arg(ap, double); + va_end(ap); + + CHECK_INVARIANT (xi.x == x_g.x && xi.y == x_g.y); + CHECK_INVARIANT (s == (short)i_2); + CHECK_INVARIANT (f == (float)d_2); + CHECK_INVARIANT (ld == ld_1); + CHECK_INVARIANT (c == (char)i_1); + CHECK_INVARIANT (d == d_3); +} + +void baz (int i, ... ) +{ + struct vfoo vx, vx2; + __vector signed int v_i, v2_i; + int j, k, l; + va_list ap; + va_start(ap, i); + v_i = va_arg(ap, __vector signed int); /* { dg-bogus "non-POD type" } */ + j = va_arg(ap, int); + vx = va_arg(ap, struct vfoo); /* { dg-bogus "non-POD type" } */ + k = va_arg(ap, int); + v2_i = va_arg(ap, __vector signed int); /* { dg-bogus "non-POD type" } */ + l = va_arg(ap, int); + vx2 = va_arg(ap, struct vfoo); /* { dg-bogus "non-POD type" } */ + va_end(ap); + + CHECK_INVARIANT (vec_all_eq (v_i, v_g)); + CHECK_INVARIANT (j == i_1); + CHECK_INVARIANT (vx.x == vx_g.x && vec_all_eq(vx.v, vx_g.v) && vx.y == vx_g.y); + CHECK_INVARIANT (k == i_1); + CHECK_INVARIANT (vec_all_eq (v2_i, v2_g)); + CHECK_INVARIANT (l == i_1); + CHECK_INVARIANT (vx2.x == vx2_g.x && vec_all_eq(vx2.v, vx2_g.v) && vx2.y == vx2_g.y); +} + +void quux (int i, ... ) +{ + __vector signed int v_i, v2_i; + union u vi, v2i; + va_list ap; + va_start(ap, i); + v_i = va_arg(ap, __vector signed int); + v2_i = va_arg(ap, __vector signed int); + va_end(ap); + vi.v = v_i; + v2i.v = v2_i; + + CHECK_INVARIANT (vec_all_eq (v_i, v_g)); + CHECK_INVARIANT (vec_all_eq (v2_i, v_g)); + CHECK_INVARIANT (vec_all_eq (vi.v, v_g)); + CHECK_INVARIANT (vec_all_eq (v2i.v, v_g)); +} + +void baz2 (int i, ... ) +{ + struct vfoo vx; + union u vxi; + va_list ap; + va_start(ap, i); + vx = va_arg(ap, struct vfoo); + va_end(ap); + vxi.v = vx.v; + + CHECK_INVARIANT (vx.x == vx_g.x && vec_all_eq(vx.v, vx_g.v) && vx.y == vx_g.y); + CHECK_INVARIANT (vec_all_eq (vxi.v, vx_g.v)); +} + +int main(void) +{ + CHECK_INVARIANT (sizeof(struct foo) == 8 && sizeof(struct vfoo) == 48); + + bar(i_1, x_g, (short)i_2, (float)d_2, ld_1, (char)i_1, d_3); + baz(i_1, v_g, /* { dg-bogus "non-POD type" "" { target *-*-* } 122 } */ + i_1, vx_g, /* { dg-bogus "non-POD type" "" { target *-*-* } 122 } */ + i_1, v2_g, /* { dg-bogus "non-POD type" "" { target *-*-* } 122 } */ + i_1, vx2_g); /* { dg-bogus "non-POD type" } */ + quux(i_1, v_g, /* { dg-bogus "non-POD type" "" { target *-*-* } 124 } */ + v_g); /* { dg-bogus "non-POD type" } */ + baz2(i_1, vx_g); /* { dg-bogus "non-POD type" } */ + + return 0; +} + diff --git a/gcc/testsuite/g++.dg/altivec-5.C b/gcc/testsuite/g++.dg/altivec-5.C new file mode 100644 index 00000000000..9cfa64470d6 --- /dev/null +++ b/gcc/testsuite/g++.dg/altivec-5.C @@ -0,0 +1,19 @@ +/* APPLE LOCAL file AltiVec */ +/* Test for AltiVec type overloading. */ +/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-options "-faltivec" } */ + void foo(vector unsigned char) { } + void foo(vector signed char) { } + void foo(vector bool char) { } + void foo(vector unsigned short) { } + void foo(vector signed short) { } + void foo(vector bool short) { } + void foo(vector unsigned int) { } + void foo(vector signed int) { } + void foo(vector bool int) { } + void foo(vector float) { } + void foo(vector pixel) { } + void foo(int) { } + void foo(unsigned int) { } + void foo(float) { } + void foo(bool) { } diff --git a/gcc/testsuite/g++.dg/altivec-7.C b/gcc/testsuite/g++.dg/altivec-7.C new file mode 100644 index 00000000000..74467361dd9 --- /dev/null +++ b/gcc/testsuite/g++.dg/altivec-7.C @@ -0,0 +1,66 @@ +/* APPLE LOCAL file AltiVec */ +/* { dg-do run { target powerpc*-*-* } } */ +/* { dg-options "-faltivec" } */ + + +extern "C" void abort(void); + +void CMP (vector unsigned char v, vector unsigned char v1) +{ + union { + vector unsigned char vv; + unsigned char s[16]; + } r, r1; + r.vv = v; + r1.vv = v1; + + for (int i=0; i < 16; i++) + if (r.s[i] != r1.s[i]) + abort(); + return; +} + +#define TEST_FUNCTION_TEMPLATE + +#ifdef TEST_FUNCTION_TEMPLATE +template <int I> +#endif +void vectorTest() +{ + typedef vector unsigned char VUC; + + // Multiple initializers with expressions + const unsigned char kFoo = 0; + enum { kBar = 1 }; + VUC v1 = {kFoo,kBar,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + VUC v3 = (VUC)(kFoo,kBar,2,3,4,5,6,7,8,9,10,11,12,13,14,15); + CMP (v1, v3); + + VUC v2 = {kBar*kFoo,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + VUC v4 = (VUC)(kBar*kFoo,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15); + CMP (v2, v4); + + // Single initializers + VUC v5 = {42}; + VUC v7 = (VUC)(42); + CMP (v5, v7); + + VUC v6 = {40+2}; + VUC v8 = (VUC)(40+2); + CMP (v6, v8); + + VUC v9 = {I+5}; + VUC v11 = (VUC)(I+5); + CMP (v9, v11); +} + + +int main (int argc, char * const argv[]) +{ +#ifdef TEST_FUNCTION_TEMPLATE + vectorTest<0>(); +#else + vectorTest(); +#endif + return 0; +} diff --git a/gcc/testsuite/g++.dg/altivec-8.C b/gcc/testsuite/g++.dg/altivec-8.C new file mode 100644 index 00000000000..5e6b75c1b62 --- /dev/null +++ b/gcc/testsuite/g++.dg/altivec-8.C @@ -0,0 +1,31 @@ +/* APPLE LOCAL file AltiVec */ +/* { dg-do run { target powerpc*-*-* } } */ +/* { dg-options "-faltivec" } */ + +extern "C" void abort(); + +void check_eq (vector signed short v1, vector signed short v2) +{ + if (!vec_all_eq (v1, v2)) + abort(); + return; +} + +int main() +{ + int r; + + vector signed short vboundary[8] = { + (vector signed short)(0), + (vector signed short)(1), + (vector signed short)(2), + (vector signed short)(3), + (vector signed short)(4), + (vector signed short)(5), + (vector signed short)(6), + (vector signed short)(7) + }; + for (r = 0; r < 8; r++) + check_eq (vboundary[r], (vector signed short)(r,r,r,r,r,r,r,r)); + return 0; +} diff --git a/gcc/testsuite/g++.dg/apple-altivec-1.C b/gcc/testsuite/g++.dg/apple-altivec-1.C new file mode 100644 index 00000000000..c070de43f6c --- /dev/null +++ b/gcc/testsuite/g++.dg/apple-altivec-1.C @@ -0,0 +1,9 @@ +/* APPLE LOCAL file AltiVec */ +/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-options "-faltivec" } */ + +void foo() { + vector bool int boolVector = (vector bool int) vec_splat_u32(3); + boolVector = vec_sld( boolVector, boolVector, + 1 ); /* { dg-bogus "no instance of overloaded" } */ +} diff --git a/gcc/testsuite/g++.dg/apple-altivec-2.C b/gcc/testsuite/g++.dg/apple-altivec-2.C new file mode 100644 index 00000000000..4e6d70b483b --- /dev/null +++ b/gcc/testsuite/g++.dg/apple-altivec-2.C @@ -0,0 +1,32 @@ +/* APPLE LOCAL file */ +/* { dg-do run { target powerpc*-*-* } } */ +/* { dg-options "-maltivec" } */ + +#include <altivec.h> + +extern "C" void abort (void); + +int main() +{ + vector float tiny = (vector float) ((vector unsigned int) (0x00800000, 0xBF800000, 0x3E800000, 0)); + unsigned int af[4] = { + (unsigned int)(unsigned int)0x00800000, + (unsigned int)(unsigned int)0xBF800000, + (unsigned int)(unsigned int)0x3E800000, + (unsigned int)(unsigned int)0}; + + union u { + vector float vf; + unsigned int ai[4]; + }vu; + int i; + + vu.vf = tiny; + + for (i=0; i < 4; i++) + if (af[i] != vu.ai[i]) + abort(); + + return 0; +} + diff --git a/gcc/testsuite/g++.dg/apple-altivec-6.C b/gcc/testsuite/g++.dg/apple-altivec-6.C new file mode 100644 index 00000000000..90c2d48abe1 --- /dev/null +++ b/gcc/testsuite/g++.dg/apple-altivec-6.C @@ -0,0 +1,15 @@ +/* APPLE LOCAL file */ +/* { dg-do run { target powerpc*-*-* } } */ +/* { dg-options "-maltivec -pedantic" } */ + +int main() + { + typedef unsigned char UC; + typedef vector unsigned char VUC; + + const UC kBar = 7; + VUC vBar1 = (VUC)(kBar); + VUC vBar2 = {kBar}; + VUC vBar3 = (VUC){kBar}; + return 0; + } diff --git a/gcc/testsuite/g++.dg/apple-altivec-test.C b/gcc/testsuite/g++.dg/apple-altivec-test.C new file mode 100644 index 00000000000..723ed86006d --- /dev/null +++ b/gcc/testsuite/g++.dg/apple-altivec-test.C @@ -0,0 +1,57 @@ +/* APPLE LOCAL file */ +/* { dg-do run { target powerpc*-*-* } } */ +/* { dg-options "-maltivec" } */ + +#include <altivec.h> + +extern "C" void abort(); + +class Star +{ + public: + inline vector float foo() const; + + Star() + { + data.f[0] = 1.0; data.f[1] = 2.0; data.f[2] = 3.0, data.f[3] = 4.0; + } + + private: + union { + float f[4]; + vector float v; + } data; + + friend vector float fTest(const Star &); +}; + +vector float Star::foo() const +{ + return data.v; +} + +vector float fTest(const Star & val) +{ + vector float vf = val.foo(); + return vf; +} + +int main() { + + Star s; + + union u { + float f[4]; + vector float v; + } data; + + data.v = fTest(s); + for (int i=0 ; i < 4; i++) + if (data.f[i] != (float)(i+1)) + abort(); + return 0; +} + + + + diff --git a/gcc/testsuite/g++.dg/asm-block-1.C b/gcc/testsuite/g++.dg/asm-block-1.C new file mode 100644 index 00000000000..63446417a12 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-block-1.C @@ -0,0 +1,75 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test asm-syntax blocks within functions. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +extern "C" void abort (void); + +int +foo (int argx, int argy) +{ + register int locx = argx, locy = argy, rslt; + asm { + add rslt,locx,locy + } + return rslt; +} + +/* Exercise corners of syntax. */ + +int +bar () +{ + register int rslt = 100; + asm { + // Combos of instructions on a line + + nop + ; + nop + nop ; + ; nop + nop ; nop + ; nop ;;; li r3,95 ; nop ; + // '.' in an opcode + add. r6,r6,r5 + } + return rslt; +} + +int baz () +{ + register int rslt = 1; + asm { + li r8,29+(2 * 3); + add rslt,rslt,r8; + b @192 + @34 + nop + ble+ @34 + b forward + abc: + b abc + @abc: + b @abc + forward: ; @192: + nop + ; + sameline: nop + x1: @x2 @x3: nop ; @x4 x5: + } + return rslt; +} + +int +main () +{ + if (foo (22, 23) != 45) + abort (); + if (bar () != 100) + abort (); + if (baz () != 36) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/asm-block-2.C b/gcc/testsuite/g++.dg/asm-block-2.C new file mode 100644 index 00000000000..6248c2dcc63 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-block-2.C @@ -0,0 +1,101 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test structure refs in asm-syntax blocks within functions. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks -O2" } */ + +extern "C" void abort(void); + +typedef struct astruct { + int arr[40]; + char charfield; + int fieldx; +} atypedef; + +union aunion { + int field1; + int field2; +}; + +class aclass { + public: + double headfield; + int intfield; +}; + +int fun1 (struct astruct *x) +{ + int loc; + asm { + lwz loc, astruct.fieldx(x) + addi loc, loc, 42 + } + return loc; +} + +int fun2 (atypedef *x) +{ + int loc; + + asm { + lwz loc, atypedef.fieldx(r3) + addi loc, loc, 43 + } + return loc; +} + +int fun3(int arg) +{ + int loc; + + asm { + mr loc, r3 + addi loc, loc, aunion.field1 + } + return loc; +} + +int fun4 (struct astruct *arg) +{ + int loc; + asm { + lbz loc, arg->charfield + addi loc, loc, 1 + } + return loc; +} + +int fun5 (aclass *x) +{ + int loc; + asm { + lwz loc, aclass.intfield(x) + addi loc, loc, 95 + } + return loc; +} + +struct astruct glob; +union uglob; + +int +main () +{ + aclass *localobj = new aclass; + + glob.charfield = 'b'; + glob.fieldx = 22; + if (fun1 (&glob) != 64) + abort (); + if (fun2 (&glob) != 65) + abort (); + if (fun3 (89) != 89) + abort (); + if (fun4 (&glob) != 'c') + abort (); + localobj->intfield = 55; + if (fun5 (localobj) != 150) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/asm-block-3.C b/gcc/testsuite/g++.dg/asm-block-3.C new file mode 100644 index 00000000000..b7fa0fe475a --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-block-3.C @@ -0,0 +1,24 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test C++ keywords in asm-syntax blocks within functions. */ + +/* { dg-do compile { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +void +bar () +{ + register unsigned int theColor; + register unsigned char bbb; + asm {and++ bbb,theColor,24; }; + asm {and bbb,theColor,24; }; + asm {and_eq bbb,theColor,24; }; + asm {bitand bbb,theColor,24; }; + asm {bitor bbb,theColor,24; }; + asm {compl bbb,theColor,24; }; + asm {not bbb,theColor,24; }; + asm {not_eq bbb,theColor,24; }; + asm {or bbb,theColor,24; }; + asm {or_eq bbb,theColor,24; }; + asm {xor bbb,theColor,24; }; + asm {xor_eq bbb,theColor,24; }; +} diff --git a/gcc/testsuite/g++.dg/asm-block-4.C b/gcc/testsuite/g++.dg/asm-block-4.C new file mode 100644 index 00000000000..75886faa038 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-block-4.C @@ -0,0 +1,13 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test C++ keywords that are binary operators in asm-syntax blocks within functions. */ + +/* { dg-do compile { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +int baz (int arg1) { + asm { + mr r2, arg1 + add r3, r2, r2 + and r3, arg1, r3 + } +} diff --git a/gcc/testsuite/g++.dg/asm-function-1.C b/gcc/testsuite/g++.dg/asm-function-1.C new file mode 100644 index 00000000000..c546c1f0dde --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-1.C @@ -0,0 +1,39 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test whole asm functions. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks -O2" } */ + +extern "C" void abort (void); + +asm int +foo (register int argx, register int argy) +{ + add r3, argx, argy +} + +#define rsltreg r3 + +asm int +foo1 (register int argx, register int argy) +{ register int loc1, loc2; + nop + li loc1, 100 + li rsltreg,0 + b @a34 + add rsltreg, argx, argy +@a34 + add rsltreg, rsltreg, loc1 + blr +} + +int +main () +{ + if (foo (22, 23) != 45) + abort (); + if (foo1 (1, 2) != 100) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/asm-function-10.C b/gcc/testsuite/g++.dg/asm-function-10.C new file mode 100644 index 00000000000..c3ebc52bf65 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-10.C @@ -0,0 +1,21 @@ +/* APPLE LOCAL file CW asm blocks */ +/* { dg-do assemble { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +struct tDummyStruct +{ + unsigned long fDummy; + unsigned long fSample; +}; + +asm void foo() +{ + lwzu r1,(sizeof(tDummyStruct))(r2) // works + lwzu r1,sizeof(tDummyStruct)(r2) +} + +int main (int argc, char * const argv[]) +{ + foo(); +} + diff --git a/gcc/testsuite/g++.dg/asm-function-11.C b/gcc/testsuite/g++.dg/asm-function-11.C new file mode 100644 index 00000000000..c46d4c5a292 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-11.C @@ -0,0 +1,24 @@ +/* APPLE LOCAL file CW asm blocks */ +/* { dg-do assemble { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +struct tDummyStruct +{ + unsigned long fDummy; + unsigned long fSample; +}; + +asm void foo() +{ + lwz r1,-8+tDummyStruct.fSample(r2) + stw r1,-8+tDummyStruct.fSample(r2) + lwz r1,-8-(tDummyStruct.fSample-tDummyStruct.fDummy)(r2) + stw r1,-8-(tDummyStruct.fSample-tDummyStruct.fDummy)(r2) +} + +int main (int argc, char * const argv[]) +{ + foo(); +} + + diff --git a/gcc/testsuite/g++.dg/asm-function-12.C b/gcc/testsuite/g++.dg/asm-function-12.C new file mode 100644 index 00000000000..c518550fcdd --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-12.C @@ -0,0 +1,18 @@ +/* APPLE LOCAL file CW asm blocks */ +/* { dg-do assemble { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +asm void foo() +{ + b .+8 + bl .+24 + b .-8 + bl .-32 + andi. r1, r0, 3 +} + +int main (int argc, char * const argv[]) +{ + foo(); +} + diff --git a/gcc/testsuite/g++.dg/asm-function-13.C b/gcc/testsuite/g++.dg/asm-function-13.C new file mode 100644 index 00000000000..ace3cba12ef --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-13.C @@ -0,0 +1,26 @@ +/* APPLE LOCAL file CW asm blocks */ +/* { dg-do assemble { target powerpc*-*-* } } */ +/* { dg-options "-fasm-blocks" } */ + +asm void foo() +{ + .align 15 + andi. r1,r2, 3 + .align 10 + b .+8 + .align 4 + b .-16 + .align 3 + lha r1, 4(r3) + .align 4 + add r1,r2,r3 + .align 3 + .align 4 +} + +int main (int argc, char * const argv[]) +{ + foo(); +} + + diff --git a/gcc/testsuite/g++.dg/asm-function-2.C b/gcc/testsuite/g++.dg/asm-function-2.C new file mode 100644 index 00000000000..87f46a6b787 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-2.C @@ -0,0 +1,75 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test whole asm functions. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks -O2" } */ + +extern "C" void abort(void); + +asm void normal_fn () +{ + nop + nop +} + +asm void nofralloc_fn () +{ + nofralloc + nop + blr +} + +asm void fralloc_fn () +{ + fralloc + nop + nop +} + +asm int fralloc_fn_1 () +{ + fralloc + mr r4,r1 + frfree + sub r3,r4,r1 + blr +} + +asm int fralloc_fn_2 () +{ + fralloc 1000 + nop + frfree + blr +} + +asm int fralloc_fn_3 () +{ + int loc1, loc2; + fralloc 41 + nop + mr r3, loc2 + frfree + mr r3, loc1 + blr +} + +asm int f6 () +{ + opword 0x386004d2 /* li r3,1234 */ +} + +main() +{ + normal_fn (); + nofralloc_fn (); + fralloc_fn (); + /* + fralloc_fn_1 (); + fralloc_fn_2 (); + fralloc_fn_3 (); + */ + if (f6 () != 1234) + abort (); + return 0; +} diff --git a/gcc/testsuite/g++.dg/asm-function-3.C b/gcc/testsuite/g++.dg/asm-function-3.C new file mode 100644 index 00000000000..8a05a300004 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-3.C @@ -0,0 +1,26 @@ +/* APPLE LOCAL file CW asm blocks */ +/* More tests of asm functions. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks -O2" } */ + +extern "C" void abort(void); + +/* Return 0 if xer and spr1 both have the same data. */ + +asm int +test_spr () +{ + mfspr r5,xer + mfspr r4,spr1 + sub r3,r4,r5 +} + +int +main () +{ + if (test_spr ()) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/asm-function-4.C b/gcc/testsuite/g++.dg/asm-function-4.C new file mode 100644 index 00000000000..eb1baa76b83 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-4.C @@ -0,0 +1,62 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test asm with macros. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks -O2" } */ + +extern "C" void abort(void); + +#define mac1 add r3, argx, argy + +asm int +foo (register int argx, register int argy) +{ + mac1 +} + +#define rsltreg r3 +#define mac2(x,y) add rsltreg,x,y + +asm int +foo1 (register int argx, register int argy) +{ + register int loc1, loc2; + nop + li loc1, 100 + li rsltreg,0 + b @a34 + mac2(argx,argy) +@a34 + mac2(rsltreg,loc1) + blr +} + +#define limac li +#define num 48 + +asm int foo2(int x, float y) +{ +#pragma unused(x) +#pragma unused(x,y) + limac rsltreg, num; +#define mac3(zzz) \ + limac r4, zzz +#pragma unused(y) + nop + mac3(num) +#pragma unused(x) + add r3,r3,r4 +} + +int +main () +{ + if (foo (22, 23) != 45) + abort (); + if (foo1 (1, 2) != 100) + abort (); + if (foo2 (100, 1.2) != 2 * num) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/asm-function-5.C b/gcc/testsuite/g++.dg/asm-function-5.C new file mode 100644 index 00000000000..f04eb4eed19 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-5.C @@ -0,0 +1,55 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test function calls in asm functions. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks -O2" } */ + +void function_with_asm_stmts () { + asm ("nop"); + asm volatile ("nop"); + __asm__ ("nop"); + __asm__ __volatile__ ("nop"); +} + +extern "C" void abort (void); + +int glob = 0; + +int other (); +extern "C" int stubfn (); +int localfn () { return other (); } + +asm void foo(int arg) +{ + nofralloc + mflr r0 + stmw r30,(-8)(r1) + stw r0,8(r1) + stwu r1,(-80)(r1) + bl stubfn + addi r1,r1,80 + lwz r0,8(r1) + lmw r30,(-8)(r1) + mtlr r0 + b localfn +} + +void bar (int arg) +{ + stubfn (); + localfn (); +} + +int stubfn () { return other(); } + +int other () { return ++glob; } + +int main () +{ + bar(34); + foo(92); + if (glob != 4) + abort (); + return 0; +} + diff --git a/gcc/testsuite/g++.dg/asm-function-6.C b/gcc/testsuite/g++.dg/asm-function-6.C new file mode 100644 index 00000000000..0c46c33476c --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-6.C @@ -0,0 +1,33 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test entry points in asm functions. */ + +/* { dg-do run { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks -O2" } */ + +#include <stdlib.h> + +int entry1(int); +int entry2(int); +int entry3(int); + +asm int foo(int x) +{ + addi x,x,45 + entry entry1 + addi x,x,1 + entry static entry2 + addi x,x,1 + entry extern entry3 + addi x,x,1 +} + +int main () +{ + if (entry1(0) != 3) + abort(); + if (entry2(89) != 91) + abort(); + if (entry3(100) != 101) + abort(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/asm-function-7.C b/gcc/testsuite/g++.dg/asm-function-7.C new file mode 100644 index 00000000000..fc877cf5fd8 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-7.C @@ -0,0 +1,17 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test la16(TABLE), lo16(TABLE), and bdnz+. */ + +/* { dg-do assemble { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +double TABLE[4]={2.0, 1./2., 3., 1.}; + +asm void SQRT() +{ + lis r3,ha16(TABLE) + addi r3,r3,lo16(TABLE) +@cycle: + fmul fp6,fp1,fp1 + bdnz+ @cycle + blr +} diff --git a/gcc/testsuite/g++.dg/asm-function-8.C b/gcc/testsuite/g++.dg/asm-function-8.C new file mode 100644 index 00000000000..5101c078628 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-8.C @@ -0,0 +1,14 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test lo16(foo)(v) and ha16(foo). */ + +/* { dg-do assemble { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +int foo; + +asm int fun1 () +{ + int v; + addis v,0,ha16(foo) + lwz r3,lo16(foo)(v) +} diff --git a/gcc/testsuite/g++.dg/asm-function-9.C b/gcc/testsuite/g++.dg/asm-function-9.C new file mode 100644 index 00000000000..576390fc1a3 --- /dev/null +++ b/gcc/testsuite/g++.dg/asm-function-9.C @@ -0,0 +1,12 @@ +/* APPLE LOCAL file CW asm blocks */ +/* Test macros with . in the opcode. */ + +/* { dg-do assemble { target powerpc*-*-darwin* } } */ +/* { dg-options "-fasm-blocks" } */ + +#define foodef() rlwinm. r4,r4,31,16,31 + +asm void foo (void) +{ + foodef() +} diff --git a/gcc/testsuite/g++.dg/const-cfstring-1.C b/gcc/testsuite/g++.dg/const-cfstring-1.C new file mode 100644 index 00000000000..23bfb0e4ee7 --- /dev/null +++ b/gcc/testsuite/g++.dg/const-cfstring-1.C @@ -0,0 +1,26 @@ +/* APPLE LOCAL file constant cfstrings */ +/* Test whether the __builtin__CFStringMakeConstantString + "function" fails gracefully when handed a non-constant + argument. This will only work on MacOS X 10.1.2 and later. */ +/* Developed by Ziemowit Laski <zlaski@apple.com>. */ + +/* { dg-do compile { target *-*-darwin* } } */ +/* { dg-options "-fconstant-cfstrings" } */ + +#import <CoreFoundation/CFString.h> + +#ifdef __CONSTANT_CFSTRINGS__ +#undef CFSTR +#define CFSTR(STR) ((CFStringRef) __builtin___CFStringMakeConstantString (STR)) +#endif + +extern int cond; +extern const char *func(void); + +int main(void) { + CFStringRef s1 = CFSTR("Str1"); + CFStringRef s2 = CFSTR(cond? "Str2": "Str3"); /* { dg-error "CFString literal expression is not constant" } */ + CFStringRef s3 = CFSTR(func()); /* { dg-error "CFString literal expression is not constant" } */ + + return 0; +} diff --git a/gcc/testsuite/g++.dg/expr/align68k-1.C b/gcc/testsuite/g++.dg/expr/align68k-1.C new file mode 100644 index 00000000000..8a89425f1d7 --- /dev/null +++ b/gcc/testsuite/g++.dg/expr/align68k-1.C @@ -0,0 +1,53 @@ +// APPLE LOCAL file test of -mdynamic-no-pic combined with 68k alignment +// Radar 3242139: Positive C++ test case +// Origin: Matt Austern <austern@apple.com> +// { dg-do run } +// { dg-options "-mdynamic-no-pic" } + +#ifdef __LP64__ +/* mac68k align not going to be supported for 64-bit, so skip entirely. */ +int main () { return 0; } +#else + +const long val1 = 0xa0b0; +const long val2 = 0x1234; + +#pragma options align=mac68k +struct X { + long x1; + long x2; +}; + +#pragma options align=reset + +void setX(X* x) { + x->x1 = val1; + x->x2 = val2; +} + +struct Y +{ + X field; + void set_vals(); +}; + +void Y::set_vals() +{ + ::setX(&field); +} + +int main() +{ + Y y; + bool ok = true; + + y.field.x1 = y.field.x2 = 0; + ok = ok && y.field.x1 == 0 && y.field.x2 == 0; + + y.set_vals(); + ok = ok && y.field.x1 == val1 && y.field.x2 == val2; + + return !ok; +} + +#endif /* __LP64__ */ diff --git a/gcc/testsuite/g++.dg/expr/align68k-2.C b/gcc/testsuite/g++.dg/expr/align68k-2.C new file mode 100644 index 00000000000..e0bebacf332 --- /dev/null +++ b/gcc/testsuite/g++.dg/expr/align68k-2.C @@ -0,0 +1,45 @@ +// APPLE LOCAL file test 68k alignment +// Radar 3313261: Positive C++ test case +// Origin: Matt Austern <austern@apple.com> +// { dg-do run } + +#ifdef __LP64__ +/* mac68k align not going to be supported for 64-bit, so skip entirely. */ +int main () { return 0; } +#else + +#pragma options align=mac68k + +typedef struct PMR { + double x; + double y; +}PMR; + +#pragma options align=reset + +static void GetDouble(double *doubleP) +{ + *doubleP = 1.; +} + +static void GetPMR(PMR *p) +{ + GetDouble(&p->x); + GetDouble(&p->y); +} + +int main(void) +{ + PMR tmp; + bool ok = true; + + tmp.x = tmp.y = 0; + ok = ok && tmp.x == 0.0 && tmp.y == 0.0; + + GetPMR(&tmp); + ok = ok && tmp.x == 1.0 && tmp.y == 1.0; + + return !ok; +} + +#endif /* __LP64__ */ diff --git a/gcc/testsuite/g++.dg/expr/cast-ptr-1.C b/gcc/testsuite/g++.dg/expr/cast-ptr-1.C new file mode 100644 index 00000000000..cb42d13ac48 --- /dev/null +++ b/gcc/testsuite/g++.dg/expr/cast-ptr-1.C @@ -0,0 +1,15 @@ +/* APPLE LOCAL file pointer casts */ +/* Test that casts of pointer to unsigned long long aren't sign extended */ +/* Author: Matt Austern <austern@apple.com> */ +/* { dg-do run } */ +/* { dg-options "-Wno-error -w" } */ + +int main () { + /* Note: test assumes sizeof(long long) >= sizeof(void*) */ + + unsigned long x1 = 0x80000000ul; + void* p = (void*) x1; + unsigned long long x2 = (unsigned long long) p; + + return !(x1 == x2); +} diff --git a/gcc/testsuite/g++.dg/expr/fieldref1.C b/gcc/testsuite/g++.dg/expr/fieldref1.C new file mode 100644 index 00000000000..b04ed137548 --- /dev/null +++ b/gcc/testsuite/g++.dg/expr/fieldref1.C @@ -0,0 +1,23 @@ +// APPLE LOCAL file - test of access to 8-byte struct field +// Radar 3309305: positive C++ test case +// Origin: Matt Austern <austern@apple.com> +// { dg-do run } + +struct X { + char array[8]; +}; + +char* get_array(X* p) { + char* p2 = p->array; + return p2; +} + +int main() +{ + X t; + X* p = &t; + char* p2 = get_array(p); + + bool ok = (void*)p == (void*)p2; + return !ok; +} diff --git a/gcc/testsuite/g++.dg/ext/altivec-apple-11.C b/gcc/testsuite/g++.dg/ext/altivec-apple-11.C new file mode 100644 index 00000000000..c5104b2635b --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/altivec-apple-11.C @@ -0,0 +1,18 @@ +/* APPLE LOCAL file AltiVec */ +/* This is a compile-only test for interaction of "-maltivec" and "-save-temps". */ +/* Author: Ziemowit Laski <zlaski@apple.com>. */ +/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-options "-save-temps -maltivec" } */ + +#define vector_float vector float +#define vector_float_foo vector float foo +#define vector_float_bar_eq vector float bar = + +/* NB: Keep the following split across three lines. */ +vector +int +a1 = { 100, 200, 300, 400 }; + +vector_float f1 = { 1.0, 2.0, 3.0, 4.0 }; +vector_float_foo = { 3.0, 4.0, 5.0, 6.0 }; +vector_float_bar_eq { 8.0, 7.0, 6.0, 5.0 }; diff --git a/gcc/testsuite/g++.dg/ext/apple-altivec-1.C b/gcc/testsuite/g++.dg/ext/apple-altivec-1.C new file mode 100644 index 00000000000..2726c81b3af --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/apple-altivec-1.C @@ -0,0 +1,43 @@ +/* APPLE LOCAL file AltiVec */ +/* Additional AltiVec PIM argument type combinations. */ + +/* { dg-do compile { target powerpc*-*-darwin* } } */ +/* { dg-options "-faltivec -Wall" } */ + +vector signed int +LoadUnalignedSI( signed int *p) +{ + vector signed int vload1 = vec_ld( 0, (vector signed int *)p); + if ( ((long)p) * 0xF){ + vector signed int vload2 = vec_ld( 16, (vector signed int *)p); + vector unsigned char vperm = vec_ldl( 0, p); + + vload1 = vec_perm(vload1, vload2, vperm); + } + return vload1; +} + +inline vector float Reciprocal( vector float v ) +{ + + vector float estimate = vec_re( v ); + + return vec_madd( vec_nmsub( estimate, v, (vector float) (1.0) ), estimate, estimate ); +} + +void foo(void) { + vector bool char vbc1 = (vector bool char)(255); + vector pixel vp1, vp2; + vector float vf1, vf2; + vector unsigned char vuc1; + vector unsigned short vus1, vus2; + vector bool short vbs1, vbs2; + vector signed short vss1; + vector signed int vsi1, vsi2; + vbc1 = vec_splat (vbc1, 9); + vp2 = vec_splat (vp1, 7); + vf1 = vec_splat (vf2, 31); + vuc1 = vec_pack (vus1, vus2); + vbc1 = vec_pack (vbs1, vbs2); + vss1 = vec_pack (vsi1, vsi2); +} diff --git a/gcc/testsuite/g++.dg/ext/apple-altivec-2.C b/gcc/testsuite/g++.dg/ext/apple-altivec-2.C new file mode 100644 index 00000000000..6e3d959bb3d --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/apple-altivec-2.C @@ -0,0 +1,398 @@ +/* APPLE LOCAL file AltiVec */ +/* Check for presence of AltiVec PIM "specific operations". */ + +/* { dg-do compile { target powerpc*-*-darwin* } } */ +/* { dg-options "-faltivec -Wall" } */ + +vector signed int +specific_operations( signed int *p) +{ + vector unsigned int vui1, vui2; + vector unsigned short vus1, vus2; + vector unsigned char vuc1, vuc2; + vector signed int vsi1, vsi2; + vector signed short vss1, vss2; + vector signed char vsc1, vsc2; + vector bool int vbi1, vbi2; + vector bool short vbs1, vbs2; + vector bool char vbc1, vbc2; + vector float vf1, vf2; + vector pixel vp1, vp2; + + vuc1 = vec_lvebx (8, (unsigned char *)p); + vss1 = vec_lvehx (4, (short *)p); + vf1 = vec_lvewx (2, (float *)p); + + vsi1 = vec_lvx (1, (vector signed int *)p); + vp1 = vec_lvxl (16, (vector pixel *)p); + + vec_stvebx (vuc1, 2, (char *)p); + vec_stvehx (vp1, 4, (unsigned short *)p); + vec_stvewx (vf1, 1, (float *)p); + + vec_stvx (vbi1, 12, (vector int bool *)p); + vec_stvxl (vp1, 11, (vector pixel *)p); + + vui1 = vec_vaddcuw (vui1, vui2); + vf1 = vec_vaddfp (vf1, vf2); + + vsc1 = vec_vaddsbs (vsc1, vsc2); + vss1 = vec_vaddshs (vss1, vss2); + vsi1 = vec_vaddsws (vsi1, vsi2); + vuc1 = vec_vaddubs (vuc1, vuc2); + vus1 = vec_vadduhs (vus1, vus2); + vui1 = vec_vadduws (vui1, vui2); + vuc1 = vec_vaddubm (vuc1, vuc2); + vus1 = vec_vadduhm (vus1, vus2); + vui1 = vec_vadduwm (vui1, vui2); + + vsc1 = vec_vand (vsc1, vsc2); + vss1 = vec_vandc (vss1, vss2); + + vsc1 = vec_vavgsb (vsc1, vsc2); + vss1 = vec_vavgsh (vss1, vss2); + vsi1 = vec_vavgsw (vsi1, vsi2); + vuc1 = vec_vavgub (vuc1, vuc2); + vus1 = vec_vavguh (vus1, vus2); + vui1 = vec_vavguw (vui1, vui2); + + vf1 = vec_vcfsx (vsi1, 4); + vf2 = vec_vcfux (vui1, 3); + + vsi1 = vec_vcmpbfp (vf1, vf2); + vbi1 = vec_vcmpeqfp (vf1, vf2); + + vbc1 = vec_vcmpequb (vuc1, vuc2); + vbs2 = vec_vcmpequh (vus1, vus2); + vbi1 = vec_vcmpequw (vui1, vui2); + + vbi1 = vec_vcmpgefp (vf1, vf2); + vbi2 = vec_vcmpgtfp (vf1, vf2); + + vbc1 = vec_vcmpgtsb (vsc1, vsc2); + vbs1 = vec_vcmpgtsh (vss1, vss2); + vbi1 = vec_vcmpgtsw (vsi1, vsi2); + + vbc1 = vec_vcmpgtub (vuc1, vuc2); + vbs1 = vec_vcmpgtuh (vus1, vus2); + vbi1 = vec_vcmpgtuw (vui1, vui2); + + vsi1 = vec_vctsxs (vf1, 22); + vui1 = vec_vctuxs (vf2, 30); + + vf2 = vec_vexptefp (vf1); + vf1 = vec_vlogefp (vf2); + vf2 = vec_vmaddfp (vf1, vf2, vf2); + + vf1 = vec_vmaxfp (vf1, vf2); + + vsc1 = vec_vmaxsb (vsc1, vsc2); + vss1 = vec_vmaxsh (vss1, vss2); + vsi1 = vec_vmaxsw (vsi1, vsi2); + vuc1 = vec_vmaxub (vuc1, vuc2); + vus1 = vec_vmaxuh (vus1, vus2); + vui1 = vec_vmaxuw (vui1, vui2); + + vbc1 = vec_vmrghb (vbc1, vbc2); + vp1 = vec_vmrghh (vp1, vp2); + vf2 = vec_vmrghw (vf2, vf1); + + vbc1 = vec_vmrglb (vbc1, vbc2); + vp1 = vec_vmrglh (vp1, vp2); + vf2 = vec_vmrglw (vf2, vf1); + + vf1 = vec_vminfp (vf1, vf2); + + vsc1 = vec_vminsb (vsc1, vsc2); + vss1 = vec_vminsh (vss1, vss2); + vsi1 = vec_vminsw (vsi1, vsi2); + vuc1 = vec_vminub (vuc1, vuc2); + vus1 = vec_vminuh (vus1, vus2); + vui1 = vec_vminuw (vui1, vui2); + + vss1 = vec_vmhaddshs (vss1, vss2, vss2); + vss2 = vec_vmhraddshs (vss1, vss2, vss2); + vus1 = vec_vmladduhm (vus1, vus1, vus2); + vui1 = vec_vmsumubm (vuc1, vuc2, vui1); + vsi1 = vec_vmsummbm (vsc1, vuc2, vsi1); + vsi2 = vec_vmsumshm (vss1, vss2, vsi1); + vui1 = vec_vmsumuhm (vus1, vus2, vui2); + vui2 = vec_vmsumuhs (vus1, vus2, vui1); + vsi2 = vec_vmsumshs (vss1, vss1, vsi2); + + vus1 = vec_vmuleub (vuc1, vuc2); + vss1 = vec_vmulesb (vsc1, vsc2); + vui1 = vec_vmuleuh (vus1, vus2); + vsi1 = vec_vmulesh (vss1, vss2); + + vus2 = vec_vmuloub (vuc1, vuc2); + vss2 = vec_vmulosb (vsc1, vsc2); + vui2 = vec_vmulouh (vus1, vus2); + vsi2 = vec_vmulosh (vss1, vss2); + + vf1 = vec_vnmsubfp (vf1, vf2, vf1); + + vp1 = vec_vnor (vp1, vp2); + vf2 = vec_vor (vf2, vbi1); + vf2 = vec_vxor (vf2, vbi1); + + vsc1 = vec_vpkuhum (vss1, vss2); + vbs1 = vec_vpkuwum (vbi1, vbi2); + vp1 = vec_vpkpx (vui1, vui2); + vuc1 = vec_vpkuhus (vus1, vus1); + vsc1 = vec_vpkshss (vss1, vss2); + vus1 = vec_vpkuwus (vui1, vui2); + vss2 = vec_vpkswss (vsi1, vsi1); + vuc1 = vec_vpkshus (vss1, vss2); + vus1 = vec_vpkswus (vsi1, vsi1); + + vp1 = vec_vperm (vp1, vp2, vuc1); + + vf1 = vec_vrefp (vf2); + vf2 = vec_vrfin (vf1); + vf1 = vec_vrsqrtefp (vf2); + + vuc1 = vec_vrlb (vuc1, vuc2); + vss1 = vec_vrlh (vss2, vss1); + vui2 = vec_vrlw (vui2, vui1); + + vf1 = vec_vsel (vf2, vf1, vbi1); + + vuc1 = vec_vslb (vuc1, vuc2); + vss1 = vec_vslh (vss2, vss1); + vui2 = vec_vslw (vui2, vui1); + + vp1 = vec_vsldoi (vp2, vp1, 14); + vp2 = vec_vsl (vp1, vuc1); + vp1 = vec_vslo (vp2, vuc1); + + vbc1 = vec_vspltb (vbc1, 9); + vp2 = vec_vsplth (vp1, 7); + vf1 = vec_vspltw (vf2, 31); + vsc2 = vec_vspltisb (30); + vss1 = vec_vspltish (29); + vsi1 = vec_vspltisw (28); + + vuc1 = vec_vsrb (vuc1, vuc2); + vss1 = vec_vsrh (vss2, vss1); + vui2 = vec_vsrw (vui2, vui1); + vuc2 = vec_vsrab (vuc1, vuc2); + vss2 = vec_vsrah (vss2, vss1); + vui1 = vec_vsraw (vui2, vui1); + vp2 = vec_vsr (vp1, vuc1); + vp1 = vec_vsro (vp2, vuc1); + + vui1 = vec_vsubcuw (vui1, vui2); + vf1 = vec_vsubfp (vf1, vf2); + + vsc1 = vec_vsubsbs (vsc1, vsc2); + vss1 = vec_vsubshs (vss1, vss2); + vsi1 = vec_vsubsws (vsi1, vsi2); + vuc1 = vec_vsububs (vuc1, vuc2); + vus1 = vec_vsubuhs (vus1, vus2); + vui1 = vec_vsubuws (vui1, vui2); + vuc1 = vec_vsububm (vuc1, vuc2); + vus1 = vec_vsubuhm (vus1, vus2); + vui1 = vec_vsubuwm (vui1, vui2); + + vui2 = vec_vsum4ubs (vuc1, vui1); + vsi1 = vec_vsum4sbs (vsc2, vsi1); + vsi1 = vec_vsum2sws (vsi1, vsi1); + vsi2 = vec_vsumsws (vsi2, vsi1); + + vf2 = vec_vrfiz (vf1); + + vbs1 = vec_vupkhsb (vbc1); + vui1 = vec_vupkhpx (vp1); + vbi1 = vec_vupkhsh (vbs1); + + vss1 = vec_vupklsb (vsc1); + vui1 = vec_vupklpx (vp2); + vbi1 = vec_vupklsh (vbs1); + + return vsi1; +} + +/* { dg-final { scan-assembler "\tlvebx " } } */ +/* { dg-final { scan-assembler "\tlvehx " } } */ +/* { dg-final { scan-assembler "\tlvewx " } } */ +/* { dg-final { scan-assembler "\tlvx " } } */ +/* { dg-final { scan-assembler "\tlvxl " } } */ +/* { dg-final { scan-assembler "\tstvebx " } } */ +/* { dg-final { scan-assembler "\tstvehx " } } */ +/* { dg-final { scan-assembler "\tstvewx " } } */ +/* { dg-final { scan-assembler "\tstvx " } } */ +/* { dg-final { scan-assembler "\tstvxl " } } */ + +/* { dg-final { scan-assembler "\tvaddcuw " } } */ +/* { dg-final { scan-assembler "\tvaddfp " } } */ +/* { dg-final { scan-assembler "\tvaddsbs " } } */ +/* { dg-final { scan-assembler "\tvaddshs " } } */ +/* { dg-final { scan-assembler "\tvaddsws " } } */ +/* { dg-final { scan-assembler "\tvaddubs " } } */ +/* { dg-final { scan-assembler "\tvadduhs " } } */ +/* { dg-final { scan-assembler "\tvadduws " } } */ +/* { dg-final { scan-assembler "\tvaddubm " } } */ +/* { dg-final { scan-assembler "\tvadduhm " } } */ +/* { dg-final { scan-assembler "\tvadduwm " } } */ + +/* { dg-final { scan-assembler "\tvand " } } */ +/* { dg-final { scan-assembler "\tvandc " } } */ + +/* { dg-final { scan-assembler "\tvavgsb " } } */ +/* { dg-final { scan-assembler "\tvavgsh " } } */ +/* { dg-final { scan-assembler "\tvavgsw " } } */ +/* { dg-final { scan-assembler "\tvavgub " } } */ +/* { dg-final { scan-assembler "\tvavguh " } } */ +/* { dg-final { scan-assembler "\tvavguw " } } */ + +/* { dg-final { scan-assembler "\tvcfsx " } } */ +/* { dg-final { scan-assembler "\tvcfux " } } */ + +/* { dg-final { scan-assembler "\tvcmpbfp " } } */ +/* { dg-final { scan-assembler "\tvcmpeqfp " } } */ + +/* { dg-final { scan-assembler "\tvcmpequb " } } */ +/* { dg-final { scan-assembler "\tvcmpequh " } } */ +/* { dg-final { scan-assembler "\tvcmpequw " } } */ + +/* { dg-final { scan-assembler "\tvcmpgefp " } } */ +/* { dg-final { scan-assembler "\tvcmpgtfp " } } */ + +/* { dg-final { scan-assembler "\tvcmpgtsb " } } */ +/* { dg-final { scan-assembler "\tvcmpgtsh " } } */ +/* { dg-final { scan-assembler "\tvcmpgtsw " } } */ + +/* { dg-final { scan-assembler "\tvcmpgtub " } } */ +/* { dg-final { scan-assembler "\tvcmpgtuh " } } */ +/* { dg-final { scan-assembler "\tvcmpgtuw " } } */ + +/* { dg-final { scan-assembler "\tvctsxs " } } */ +/* { dg-final { scan-assembler "\tvctuxs " } } */ + +/* { dg-final { scan-assembler "\tvexptefp " } } */ +/* { dg-final { scan-assembler "\tvlogefp " } } */ +/* { dg-final { scan-assembler "\tvmaddfp " } } */ + +/* { dg-final { scan-assembler "\tvmaxfp " } } */ +/* { dg-final { scan-assembler "\tvmaxsb " } } */ +/* { dg-final { scan-assembler "\tvmaxsh " } } */ +/* { dg-final { scan-assembler "\tvmaxsw " } } */ +/* { dg-final { scan-assembler "\tvmaxub " } } */ +/* { dg-final { scan-assembler "\tvmaxuh " } } */ +/* { dg-final { scan-assembler "\tvmaxuw " } } */ + +/* { dg-final { scan-assembler "\tvmrghb " } } */ +/* { dg-final { scan-assembler "\tvmrghh " } } */ +/* { dg-final { scan-assembler "\tvmrghw " } } */ + +/* { dg-final { scan-assembler "\tvmrglb " } } */ +/* { dg-final { scan-assembler "\tvmrglh " } } */ +/* { dg-final { scan-assembler "\tvmrglw " } } */ + +/* { dg-final { scan-assembler "\tvminfp " } } */ +/* { dg-final { scan-assembler "\tvminsb " } } */ +/* { dg-final { scan-assembler "\tvminsh " } } */ +/* { dg-final { scan-assembler "\tvminsw " } } */ +/* { dg-final { scan-assembler "\tvminub " } } */ +/* { dg-final { scan-assembler "\tvminuh " } } */ +/* { dg-final { scan-assembler "\tvminuw " } } */ + +/* { dg-final { scan-assembler "\tvmhaddshs " } } */ +/* { dg-final { scan-assembler "\tvmhraddshs " } } */ +/* { dg-final { scan-assembler "\tvmladduhm " } } */ +/* { dg-final { scan-assembler "\tvmsumubm " } } */ +/* { dg-final { scan-assembler "\tvmsummbm " } } */ +/* { dg-final { scan-assembler "\tvmsumshm " } } */ +/* { dg-final { scan-assembler "\tvmsumuhm " } } */ +/* { dg-final { scan-assembler "\tvmsumuhs " } } */ +/* { dg-final { scan-assembler "\tvmsumshs " } } */ + +/* { dg-final { scan-assembler "\tvmuleub " } } */ +/* { dg-final { scan-assembler "\tvmulesb " } } */ +/* { dg-final { scan-assembler "\tvmuleuh " } } */ +/* { dg-final { scan-assembler "\tvmulesh " } } */ + +/* { dg-final { scan-assembler "\tvmuloub " } } */ +/* { dg-final { scan-assembler "\tvmulosb " } } */ +/* { dg-final { scan-assembler "\tvmulouh " } } */ +/* { dg-final { scan-assembler "\tvmulosh " } } */ + +/* { dg-final { scan-assembler "\tvnmsubfp " } } */ + +/* { dg-final { scan-assembler "\tvnor " } } */ +/* { dg-final { scan-assembler "\tvor " } } */ +/* { dg-final { scan-assembler "\tvxor " } } */ + +/* { dg-final { scan-assembler "\tvpkuhum " } } */ +/* { dg-final { scan-assembler "\tvpkuwum " } } */ +/* { dg-final { scan-assembler "\tvpkpx " } } */ +/* { dg-final { scan-assembler "\tvpkuhus " } } */ +/* { dg-final { scan-assembler "\tvpkshss " } } */ +/* { dg-final { scan-assembler "\tvpkuwus " } } */ +/* { dg-final { scan-assembler "\tvpkswss " } } */ +/* { dg-final { scan-assembler "\tvpkshus " } } */ +/* { dg-final { scan-assembler "\tvpkswus " } } */ + +/* { dg-final { scan-assembler "\tvperm " } } */ + +/* { dg-final { scan-assembler "\tvrefp " } } */ +/* { dg-final { scan-assembler "\tvrfin " } } */ +/* { dg-final { scan-assembler "\tvrsqrtefp " } } */ + +/* { dg-final { scan-assembler "\tvrlb " } } */ +/* { dg-final { scan-assembler "\tvrlh " } } */ +/* { dg-final { scan-assembler "\tvrlw " } } */ + +/* { dg-final { scan-assembler "\tvsel " } } */ + +/* { dg-final { scan-assembler "\tvslb " } } */ +/* { dg-final { scan-assembler "\tvslh " } } */ +/* { dg-final { scan-assembler "\tvslw " } } */ + +/* { dg-final { scan-assembler "\tvsldoi " } } */ +/* { dg-final { scan-assembler "\tvsl " } } */ +/* { dg-final { scan-assembler "\tvslo " } } */ + +/* { dg-final { scan-assembler "\tvspltb " } } */ +/* { dg-final { scan-assembler "\tvsplth " } } */ +/* { dg-final { scan-assembler "\tvspltw " } } */ +/* { dg-final { scan-assembler "\tvspltisb " } } */ +/* { dg-final { scan-assembler "\tvspltish " } } */ +/* { dg-final { scan-assembler "\tvspltisw " } } */ + +/* { dg-final { scan-assembler "\tvsrb " } } */ +/* { dg-final { scan-assembler "\tvsrh " } } */ +/* { dg-final { scan-assembler "\tvsrw " } } */ +/* { dg-final { scan-assembler "\tvsrab " } } */ +/* { dg-final { scan-assembler "\tvsrah " } } */ +/* { dg-final { scan-assembler "\tvsraw " } } */ +/* { dg-final { scan-assembler "\tvsr " } } */ +/* { dg-final { scan-assembler "\tvsro " } } */ + +/* { dg-final { scan-assembler "\tvsubcuw " } } */ +/* { dg-final { scan-assembler "\tvsubfp " } } */ +/* { dg-final { scan-assembler "\tvsubsbs " } } */ +/* { dg-final { scan-assembler "\tvsubshs " } } */ +/* { dg-final { scan-assembler "\tvsubsws " } } */ +/* { dg-final { scan-assembler "\tvsububs " } } */ +/* { dg-final { scan-assembler "\tvsubuhs " } } */ +/* { dg-final { scan-assembler "\tvsubuws " } } */ +/* { dg-final { scan-assembler "\tvsububm " } } */ +/* { dg-final { scan-assembler "\tvsubuhm " } } */ +/* { dg-final { scan-assembler "\tvsubuwm " } } */ + +/* { dg-final { scan-assembler "\tvsum4ubs " } } */ +/* { dg-final { scan-assembler "\tvsum4sbs " } } */ +/* { dg-final { scan-assembler "\tvsum2sws " } } */ +/* { dg-final { scan-assembler "\tvsumsws " } } */ + +/* { dg-final { scan-assembler "\tvrfiz " } } */ + +/* { dg-final { scan-assembler "\tvupkhsb " } } */ +/* { dg-final { scan-assembler "\tvupkhpx " } } */ +/* { dg-final { scan-assembler "\tvupkhsh " } } */ + +/* { dg-final { scan-assembler "\tvupklsb " } } */ +/* { dg-final { scan-assembler "\tvupklpx " } } */ +/* { dg-final { scan-assembler "\tvupklsh " } } */ diff --git a/gcc/testsuite/g++.dg/ext/apple-altivec-3.C b/gcc/testsuite/g++.dg/ext/apple-altivec-3.C new file mode 100644 index 00000000000..b095b88eee4 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/apple-altivec-3.C @@ -0,0 +1,18 @@ +/* APPLE LOCAL file AltiVec */ +/* Vectors in template functions. */ + +/* { dg-do compile { target powerpc*-*-darwin* } } */ +/* { dg-options "-faltivec -Wall" } */ + +template<int I> +void FooBar() +{ + vector unsigned char va, vb, vc; + vc = (vector unsigned char)vec_mergeh((vector unsigned short)va, (vector unsigned short)vb); +} + +int main (int argc, char * const argv[]) +{ + FooBar<0>(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/ext/apple-altivec-4.C b/gcc/testsuite/g++.dg/ext/apple-altivec-4.C new file mode 100644 index 00000000000..0bb1dcd1d3a --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/apple-altivec-4.C @@ -0,0 +1,15 @@ +/* APPLE LOCAL file AltiVec */ +/* { dg-do compile { target powerpc*-*-* } } */ +/* { dg-options "-faltivec" } */ +/* Existing AltiVec PIM implementations allow numeric literals with + any number of bits, so long as the value is within allowed range. */ +int foo(void) +{ + vector unsigned char amask = vec_splat_u8 ( 0xFFFFFFF3L ); + vector signed short bmask = vec_splat_s16 ( 0xFFFFFFFFFFFFFFF1LL ); +} + + +/* { dg-final { scan-assembler "vspltisb.+\\-13" } } */ +/* { dg-final { scan-assembler "vspltish.+\\-15" } } */ + diff --git a/gcc/testsuite/g++.dg/ext/apple-altivec-5.C b/gcc/testsuite/g++.dg/ext/apple-altivec-5.C new file mode 100644 index 00000000000..4473881dda7 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/apple-altivec-5.C @@ -0,0 +1,31 @@ +/* APPLE LOCAL file AltiVec */ +/* Test for handling of reference vector parameters. */ +/* { dg-do compile { target powerpc*-*-darwin* } } */ +/* { dg-options "-faltivec" } */ + +struct Vect +{ + typedef vector unsigned int vector_1; + + static vector_1 ConvertPixel1(const vector_1 &source, const vector unsigned char &vp); + static vector_1 ConvertPixel2(const vector_1 source, const vector unsigned char vp); + static vector_1 ConvertPixel3(vector_1 &source, vector unsigned char &vp); + static vector_1 ConvertPixel4(vector_1 source, vector unsigned char vp); +}; + +Vect::vector_1 Vect::ConvertPixel1(const vector_1 &source, const vector unsigned char &vp) +{ + return (vector_1) vec_perm(source, source, vp); +} +Vect::vector_1 Vect::ConvertPixel2(const vector_1 source, const vector unsigned char vp) +{ + return (vector_1) vec_perm(source, source, vp); +} +Vect::vector_1 Vect::ConvertPixel3(vector_1 &source, vector unsigned char &vp) +{ + return (vector_1) vec_perm(source, source, vp); +} +Vect::vector_1 Vect::ConvertPixel4(vector_1 source, vector unsigned char vp) +{ + return (vector_1) vec_perm(source, source, vp); +} diff --git a/gcc/testsuite/g++.dg/ext/apple-altivec-6.C b/gcc/testsuite/g++.dg/ext/apple-altivec-6.C new file mode 100644 index 00000000000..7a74578d477 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/apple-altivec-6.C @@ -0,0 +1,15 @@ +/* APPLE LOCAL file AltiVec */ +/* Test for handling of volatile reference vector parameters. */ +/* { dg-do compile { target powerpc*-*-darwin* } } */ +/* { dg-options "-faltivec" } */ + +int foo(volatile vector float &i, int &j) +{ + vector unsigned char zero = vec_splat_u8(0); + vector unsigned char one = vec_splat_u8(1); + i = vec_add( (vector float)zero, (vector float)one ); + j = 5; + return 0; +} + +/* { dg-final { scan-assembler "Z3fooRVU8__vectorfRi" } } */ diff --git a/gcc/testsuite/g++.dg/ext/lvalue-cast-1.C b/gcc/testsuite/g++.dg/ext/lvalue-cast-1.C new file mode 100644 index 00000000000..ebee754f069 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/lvalue-cast-1.C @@ -0,0 +1,34 @@ +/* APPLE LOCAL file non lvalue assign */ +/* { dg-do run } */ +/* { dg-options "-fnon-lvalue-assign" } */ + +#include <stdlib.h> +#define CHECK_IF(expr) if (!(expr)) abort () + +static int global; + +void f(int &) { global = 35; } +void f(const int &) { global = 78; } + +long long_arr[2]; + +int main(void) { + + char *p; + + (long *)p = long_arr; /* { dg-warning "target of assignment not really an lvalue" } */ + ((long *)p)++; /* { dg-warning "target of assignment not really an lvalue" } */ + *(long *)p = -1; + + *p = -2; + CHECK_IF(p[-1] == 0 && p[0] == -2 && p[1] == -1); + + (long *)p += 2; /* { dg-warning "target of assignment not really an lvalue" } */ + (long *)p -= 2; /* { dg-warning "target of assignment not really an lvalue" } */ + + long x = 0; + f((int)x); + CHECK_IF(global == 78); + + return 0; +} diff --git a/gcc/testsuite/g++.dg/ext/lvalue-cast-2.C b/gcc/testsuite/g++.dg/ext/lvalue-cast-2.C new file mode 100644 index 00000000000..bfd2e29e52c --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/lvalue-cast-2.C @@ -0,0 +1,14 @@ +/* APPLE LOCAL file non lvalue assign */ +/* Allow lvalue casts in conjunction with '&'. */ +/* { dg-do compile } */ +/* { dg-options "-fnon-lvalue-assign" } */ + +int foo (void **ptr) { + return 1; +} + +int bar (void) { + char *string; + + return foo ((void **)&((char *)string)); /* { dg-warning "argument to .&. not really an lvalue" } */ +} diff --git a/gcc/testsuite/g++.dg/ext/lvalue-cond-1.C b/gcc/testsuite/g++.dg/ext/lvalue-cond-1.C new file mode 100644 index 00000000000..ad059afe9b6 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/lvalue-cond-1.C @@ -0,0 +1,32 @@ +/* APPLE LOCAL file non lvalue assign */ +/* Allow assignments to conditional expressions, as long as the second and third + operands are already lvalues. */ +/* NB: It turns out that C++ (unlike C) already allows these as lvalues, and so + no warnings whatsoever will be produced. */ +/* Author: Ziemowit Laski <zlaski@apple.com> */ +/* { dg-options "-fnon-lvalue-assign" } */ +/* { dg-do run } */ + +#include <stdlib.h> + +int g1 = 3, g2 = 5; + +void assign_val1 (int which, int value) { + (which ? g1 : g2) = value; /* { dg-bogus "target of assignment not really an lvalue" } */ +} + +void assign_val2 (int which) { + (which ? g1 : g2)++; /* { dg-bogus "target of assignment not really an lvalue" } */ +} + +int main(void) { + assign_val1 (0, 15); + if (g1 != 3 || g2 != 15) + abort (); + + assign_val2 (1); + if (g1 != 4 || g2 != 15) + abort (); + + return 0; +} diff --git a/gcc/testsuite/g++.dg/ext/new-delete-1.C b/gcc/testsuite/g++.dg/ext/new-delete-1.C new file mode 100644 index 00000000000..8f09183ab7a --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/new-delete-1.C @@ -0,0 +1,28 @@ +/* APPLE LOCAL file coalescing */ +/* Make sure that non-weak '::new' and '::delete' operators do not wind + up in a coalesced section. Whether or not they get called via a stub + from within the same translation unit is an issue we defer for later + (i.e., Positron); when called from other translation units, they do + need a stub. */ +/* Author: Ziemowit Laski <zlaski@apple.com> */ +/* { dg-do compile { target powerpc*-*-darwin* } } */ + +extern "C" void free(void *); + +void operator delete(void*) throw(); +void operator delete(void* p) throw() { free(p); } + +void operator delete(void*, int) throw(); + +void *operator new(unsigned long) throw(); +void *operator new(unsigned long) throw() { return (void *)0; } + +int *foo(void) { + int *n = new int(); + ::operator delete(n, 0); + ::operator delete(n); + return 0; +} + +/* { dg-final { scan-assembler-not "coal" } } */ +/* { dg-final { scan-assembler "bl L__ZdlPvi.stub" } } */ diff --git a/gcc/testsuite/g++.dg/ext/new-delete-2.C b/gcc/testsuite/g++.dg/ext/new-delete-2.C new file mode 100644 index 00000000000..72d6b9e3ae1 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/new-delete-2.C @@ -0,0 +1,28 @@ +/* APPLE LOCAL file coalescing */ +/* Make sure that weak '::new' and '::delete' operators wind + up in a coalesced section and get called via a stub. */ +/* Author: Ziemowit Laski <zlaski@apple.com> */ +/* { dg-do compile { target powerpc*-*-darwin* } } */ + +extern "C" void free(void *); + +void operator delete(void*) throw() __attribute__((weak)); +void operator delete(void* p) throw() { free(p); } + +void operator delete(void*, int) throw() __attribute__((weak)); + +void *operator new(unsigned long) throw() __attribute__((weak)); +void *operator new(unsigned long) throw() { return (void *)0; } + +int *foo(void) { + int *n = new int(); + ::operator delete(n, 0); + ::operator delete(n); + return 0; +} + +/* { dg-final { scan-assembler "coal" } } */ + +/* { dg-final { scan-assembler "bl L__Znwm.stub" } } */ +/* { dg-final { scan-assembler "bl L__ZdlPvi.stub" } } */ +/* { dg-final { scan-assembler "bl L__ZdlPv.stub" } } */ diff --git a/gcc/testsuite/g++.dg/kext1.C b/gcc/testsuite/g++.dg/kext1.C new file mode 100644 index 00000000000..2b8cdfa07e9 --- /dev/null +++ b/gcc/testsuite/g++.dg/kext1.C @@ -0,0 +1,11 @@ +/* APPLE LOCAL file KEXT indirect-virtual-calls --sts */ +/* Radar 3008388: Positive C++ test case. */ +/* Origin: Matt Austern <austern@apple.com> */ +/* { dg-do compile } */ +/* { dg-options "-fapple-kext" } */ + +struct B1 { }; /* ok */ +struct B2 { }; /* ok */ +struct D1 : B1 { }; /* ok */ +struct D2 : B1, B2 { }; /* ok */ +struct D3 : virtual B1 { }; /* ok */ diff --git a/gcc/testsuite/g++.dg/kext10.C b/gcc/testsuite/g++.dg/kext10.C new file mode 100644 index 00000000000..74cfa24c96b --- /dev/null +++ b/gcc/testsuite/g++.dg/kext10.C @@ -0,0 +1,23 @@ +// APPLE LOCAL file +// Radar 3988061 +// { dg-do compile { target powerpc*-*-darwin* } } +// { dg-options "-Os -static -fapple-kext" } +// the virtual call to IOHIDElement::free() is normally resolved +// at compile time, but with -fapple-kext we don't want this. +class IOHIDElement +{ +protected: + virtual ~IOHIDElement(); + virtual void free(); +}; +class IOHIDElementPrivate: public IOHIDElement +{ +protected: + virtual void free(); +}; +IOHIDElement::~IOHIDElement() {} +void IOHIDElementPrivate::free() +{ + IOHIDElement::free(); +} +// { dg-final { scan-assembler-times "IOHIDElement4free" 1} } diff --git a/gcc/testsuite/g++.dg/kext11.C b/gcc/testsuite/g++.dg/kext11.C new file mode 100644 index 00000000000..d91a686e00f --- /dev/null +++ b/gcc/testsuite/g++.dg/kext11.C @@ -0,0 +1,39 @@ +/* APPLE LOCAL file ptmf casts --bowdidge */ +/* In gcc-4.0 and beyond, kexts are not permitted to cast + pointer-to-member- functions into pointer-to-functions. + These casts should be flagged as a hard error if + -fapple-kext is an option for the compile. -fpermissive shouldn't permit + this, either. This checks for OSMemberFunctionCast in the error message + because the error advises developers to use that function to replace + these casts. + + Radar 4025923, gcc-4.0 should ban kexts from doing ptmf to ptf + conversions without OSMemberFunctionCast +*/ +/* { dg-do compile { target powerpc*-apple-darwin* } } */ +/* { dg-options "-S -static -fapple-kext -fpermissive -fno-exceptions" } */ + +typedef int(*INT_FUNC_INT)(int); +class Superclass { +public: + /* In 3.3, this would get the foo function for the class of "this". In 4.0, it + gets the foo function for Superclass. */ + virtual int init(void) {_myFunc = (INT_FUNC_INT)&Superclass::foo;}; /* { dg-error "OSMemberFunctionCast" } */ + INT_FUNC_INT _myFunc; + virtual int foo(int i) { return 2;}; +}; + +class Subclass : public Superclass { +public: + virtual int foo(int) { return 1;}; +}; + +main(int argc, char **argv) { + Superclass sup; + Subclass sub; + sup.init(); + sup.foo(1); + sub.init(); + sub.foo(1); +} + diff --git a/gcc/testsuite/g++.dg/kext2.C b/gcc/testsuite/g++.dg/kext2.C new file mode 100644 index 00000000000..992c81c6a3a --- /dev/null +++ b/gcc/testsuite/g++.dg/kext2.C @@ -0,0 +1,13 @@ +/* APPLE LOCAL file KEXT indirect-virtual-calls --sts */ +/* Radar 3008388: Positive C++ test case. */ +/* Origin: Matt Austern <austern@apple.com> */ +/* { dg-do compile } */ +/* { dg-options "-fapple-kext" } */ + +struct B1 { virtual ~B1(); virtual void f(); }; /* ok */ +struct D1 : B1 { }; /* ok */ +struct X1 : D1 { virtual void f(); }; /* ok */ + +void X1::f() { D1::f(); } /* ok */ + + diff --git a/gcc/testsuite/g++.dg/kext3.C b/gcc/testsuite/g++.dg/kext3.C new file mode 100644 index 00000000000..25b904bf78b --- /dev/null +++ b/gcc/testsuite/g++.dg/kext3.C @@ -0,0 +1,18 @@ +/* APPLE LOCAL file KEXT indirect-virtual-calls --sts */ +/* Radar 3008388: Negative C++ test case. */ +/* Origin: Matt Austern <austern@apple.com> */ +/* { dg-do compile } */ +/* { dg-options "-fapple-kext" } */ + +struct B1 { virtual ~B1(); virtual void f(); }; /* ok */ +struct D1 : B1 { }; /* ok */ +struct D2 { }; /* ok */ + +struct X1 : D1, D2 { }; /* ok */ +struct X2 : virtual D1 { }; /* ok */ + +struct Y1 : X1 { virtual void f(); }; /* ok */ +struct Y2 : X2 { virtual void f(); }; /* ok */ + +void Y1::f() { X1::f(); } /* { dg-error "indirect virtual" } */ +void Y2::f() { X2::f(); } /* { dg-error "indirect virtual" } */ diff --git a/gcc/testsuite/g++.dg/kext4.C b/gcc/testsuite/g++.dg/kext4.C new file mode 100644 index 00000000000..bdaefb61121 --- /dev/null +++ b/gcc/testsuite/g++.dg/kext4.C @@ -0,0 +1,27 @@ +/* APPLE LOCAL file KEXT double destructor */ +/* { dg-do compile } */ +/* { dg-options "-fapple-kext" } */ +/* test for use of apple_kext_compatibility on stack */ +struct B1 { + virtual ~B1(); +} __attribute__((apple_kext_compatibility)); + +struct D1 : B1 { + void operator delete(void *) { } + D1(); +}; + +struct D2 : B1 { + void operator delete(void *); + D2(); +}; + +struct D3 : B1 { + D3(); +}; + +void foo() { + D1 d1; // ok + D2 d2; // { dg-warning "is an instance of a class" } + D3 d3; // { dg-warning "is an instance of a class" } +} diff --git a/gcc/testsuite/g++.dg/kext5.C b/gcc/testsuite/g++.dg/kext5.C new file mode 100644 index 00000000000..4306c171401 --- /dev/null +++ b/gcc/testsuite/g++.dg/kext5.C @@ -0,0 +1,16 @@ +/* APPLE LOCAL file KEXT double destructor */ +/* { dg-do compile } */ +/* { dg-options "-fapple-kext" } */ + +class tTest +{ + public: + + tTest(); + ~tTest(); +}; + +void bar () +{ + tTest tests[5]; +} diff --git a/gcc/testsuite/g++.dg/kext6.C b/gcc/testsuite/g++.dg/kext6.C new file mode 100644 index 00000000000..c3f7503e53d --- /dev/null +++ b/gcc/testsuite/g++.dg/kext6.C @@ -0,0 +1,29 @@ +/* APPLE LOCAL file KEXT indirect-virtual-calls --sts */ +/* Radar 3848842 Positive C++ test case. */ +/* Origin F. Jahanian <fjahanian@apple.com> */ +/* { dg-do compile } */ +/* { dg-options "-Os -fapple-kext" } */ + +struct Integer +{ + Integer ( void ) ; + virtual ~Integer ( void ) ; +}; + +static void AppendMa(unsigned char *outBuffer); +static void AppendNonce(); + +extern "C" void afpfs_DHXLogin () +{ + unsigned char *cptr = __null; + AppendMa(cptr); + AppendNonce(); +} + +static void AppendNonce() { } + + +static void AppendMa(unsigned char *outBuffer) +{ + Integer Ma; +} diff --git a/gcc/testsuite/g++.dg/kext7.C b/gcc/testsuite/g++.dg/kext7.C new file mode 100644 index 00000000000..564e1219599 --- /dev/null +++ b/gcc/testsuite/g++.dg/kext7.C @@ -0,0 +1,20 @@ +/* APPLE LOCAL file KEXT double destructor --bowdidge */ +/* Radar 3943783 kernel extensions built with gcc-4.0 can't be loaded */ +/* { dg-do compile { target powerpc*-apple-darwin* } } */ +/* { dg-options "-S -fapple-kext" } */ + +struct Base { + virtual ~Base(); +} __attribute__((apple_kext_compatibility)); + +struct Derived : Base { + void operator delete(void *) { } + Derived(); +}; + +void foo() { + Derived d1; // ok +} +/* An implicit in-charge destructor shouldn't be created when -fapple-kext + is declared. */ +/* { dg-final { scan-assembler-not "_ZN7DerivedD1Ev" } } */ diff --git a/gcc/testsuite/g++.dg/kext8.C b/gcc/testsuite/g++.dg/kext8.C new file mode 100644 index 00000000000..399f8c03f44 --- /dev/null +++ b/gcc/testsuite/g++.dg/kext8.C @@ -0,0 +1,36 @@ +/* APPLE LOCAL file KEXT double destructor --bowdidge */ +/* Radar 3943783 kernel extensions built with gcc-4.0 can't be loaded */ +/* { dg-do compile { target powerpc*-apple-darwin* } } */ +/* { dg-options "-S -fapple-kext -fno-exceptions" } */ + +/* Here's some kext class hierarchy code. */ + + +struct Base { + virtual ~Base(); +} __attribute__((apple_kext_compatibility)); + +struct Derived : Base { + void operator delete(void *) { } + Derived(); +}; + +void foo() { + Derived d1; // ok +} + +/* Here's some inlined functions to try to trick the compiler into creating coalesced + sections. */ +inline unsigned f(unsigned n) { return n == 0 ? 0 : n + f(n-1); } + +unsigned g(unsigned n) { return f(n); } + +/* Here's some template stuff to try to trick the compiler into creating coalesced sections + another way. */ + + template <typename X> X ident(X x) { return x; } + int foo(int n) { return ident(n); } + +/* See if there's any sections with the coalesced flag. coalesced sections + currently aren't loaded by the kernel loader into memory. */ +/* { dg-final { scan-assembler-not "coalesced" } } */ diff --git a/gcc/testsuite/g++.dg/kext9.C b/gcc/testsuite/g++.dg/kext9.C new file mode 100644 index 00000000000..88293aa5558 --- /dev/null +++ b/gcc/testsuite/g++.dg/kext9.C @@ -0,0 +1,13 @@ +/* APPLE LOCAL file KEXT indirect virtual calls */ +/* Radar 3972840: Positive C++ test case */ +/* Origin: Matt Austern <austern@apple.com> */ +/* { dg-do compile } */ +/* { dg-options "-fapple-kext" } */ + +struct Base { virtual char* abc(void) const; }; + +char* Base::abc() const { return 0; } + +void f(Base* p) { + char* c = p->Base::abc(); +} diff --git a/gcc/testsuite/g++.dg/pascal-strings-1.C b/gcc/testsuite/g++.dg/pascal-strings-1.C new file mode 100644 index 00000000000..50c52015ec4 --- /dev/null +++ b/gcc/testsuite/g++.dg/pascal-strings-1.C @@ -0,0 +1,44 @@ +/* APPLE LOCAL file pascal strings */ +/* Positive C++ test cases. */ +/* Origin: Ziemowit Laski <zlaski@apple.com> */ +/* { dg-do run } */ +/* { dg-options "-fpascal-strings" } */ + +typedef __SIZE_TYPE__ size_t; +extern "C" void abort (void); +extern "C" size_t strlen (const char *s); + +const unsigned char *pascalStr1 = "\pHello, World!"; +const unsigned char *concat1 = "\pConcatenated" "string" "\pliteral"; + +const unsigned char msg1[] = "\pHello"; /* ok */ +const unsigned char *msg2 = "\pHello"; /* ok */ +const signed char msg3[] = "\pHello"; /* ok */ +const char msg4[] = "\pHello"; /* ok */ +unsigned char msg5[] = "\pHello"; /* ok */ +signed char msg7[] = "\pHello"; /* ok */ +char msg8[] = "\pHello"; /* ok */ + +int +main (void) +{ + const unsigned char *pascalStr2 = "\pGood-bye!"; + + if (strlen ((const char *)pascalStr1) != 14) + abort (); + if (*pascalStr1 != 13) + abort (); /* the length byte does not include trailing null */ + + if (strlen ((const char *)pascalStr2) != 10) + abort (); + if (*pascalStr2 != 9) + abort (); + + if (strlen ((const char *)concat1) != 26) + abort (); + if (*concat1 != 25) + abort (); + + return 0; +} + diff --git a/gcc/testsuite/g++.dg/pascal-strings-2.C b/gcc/testsuite/g++.dg/pascal-strings-2.C new file mode 100644 index 00000000000..e74c67f89c7 --- /dev/null +++ b/gcc/testsuite/g++.dg/pascal-strings-2.C @@ -0,0 +1,43 @@ +/* APPLE LOCAL file pascal strings */ +/* Negative C++ test cases. */ +/* Origin: Ziemowit Laski <zlaski@apple.com> */ +/* { dg-do compile } */ +/* { dg-options "-fpascal-strings" } */ + +const wchar_t *pascalStr1 = L"\pHi!"; /* { dg-warning "unknown escape sequence" } */ +const wchar_t *pascalStr2 = L"Bye\p!"; /* { dg-warning "unknown escape sequence" } */ + +const wchar_t *initErr0 = "\pHi"; /* { dg-error "cannot convert" } */ +const wchar_t initErr0a[] = "\pHi"; /* { dg-error "initialized from non-wide string" } */ +const wchar_t *initErr1 = "Bye"; /* { dg-error "cannot convert" } */ +const wchar_t initErr1a[] = "Bye"; /* { dg-error "initialized from non-wide string" } */ + +const char *initErr2 = L"Hi"; /* { dg-error "cannot convert" } */ +const char initErr2a[] = L"Hi"; /* { dg-error "initialized from wide string" } */ +const signed char *initErr3 = L"Hi"; /* { dg-error "cannot convert" } */ +const signed char initErr3a[] = L"Hi"; /* { dg-error "initialized from wide string" } */ +const unsigned char *initErr4 = L"Hi"; /* { dg-error "cannot convert" } */ +const unsigned char initErr4a[] = L"Hi"; /* { dg-error "initialized from wide string" } */ + +const char *pascalStr3 = "Hello\p, World!"; /* { dg-warning "unknown escape sequence" } */ + +const char *concat2 = "Hi" "\pthere"; /* { dg-warning "unknown escape sequence" } */ +const char *concat3 = "Hi" "there\p"; /* { dg-warning "unknown escape sequence" } */ + +const char *s2 = "\pGoodbye!"; /* { dg-error "invalid conversion" } */ +unsigned char *s3 = "\pHi!"; /* { dg-error "invalid conversion" } */ +char *s4 = "\pHi"; /* { dg-error "invalid conversion" } */ +signed char *s5 = "\pHi"; /* { dg-error "invalid conversion" } */ +const signed char *s6 = "\pHi"; /* { dg-error "invalid conversion" } */ + +/* the maximum length of a Pascal literal is 255. */ +const unsigned char *almostTooLong = + "\p12345678901234567890123456789012345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890123456789012345678901234567890" + "123456789012345"; /* ok */ +const unsigned char *definitelyTooLong = + "\p12345678901234567890123456789012345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890123456789012345678901234567890" + "1234567890123456"; /* { dg-error "too long" } */ diff --git a/gcc/testsuite/g++.dg/pascal-strings-3.C b/gcc/testsuite/g++.dg/pascal-strings-3.C new file mode 100644 index 00000000000..7c7cf8139ed --- /dev/null +++ b/gcc/testsuite/g++.dg/pascal-strings-3.C @@ -0,0 +1,20 @@ +/* APPLE LOCAL file pascal strings */ +/* Ensure that there are no warnings or errors issued when a Pascal string is used to + initialize an array and the NUL terminator does not fit. */ +/* Author: Ziemowit Laski <zlaski@apple.com> */ + +/* { dg-do compile } */ +/* { dg-options "-fpascal-strings" } */ + +typedef unsigned char Str15[16]; + +Str15 ggg = "\p012345678901234"; +Str15 hhh = "\p0123456789012345"; /* { dg-error "initializer.string for array of chars is too long" } */ + +int foo(void) +{ + Str15 sss = "\p012345678901234"; + Str15 ttt = "\p0123456789012345"; /* { dg-error "initializer.string for array of chars is too long" } */ + + return 0; +} diff --git a/gcc/testsuite/g++.dg/pascal-strings-4.C b/gcc/testsuite/g++.dg/pascal-strings-4.C new file mode 100644 index 00000000000..ef336990455 --- /dev/null +++ b/gcc/testsuite/g++.dg/pascal-strings-4.C @@ -0,0 +1,20 @@ +/* APPLE LOCAL file pascal strings */ +/* Ensure that Pascal strings do not get confused with ordinary C strings when + -funsigned-char is being used. */ +/* Author: Ziemowit Laski <zlaski@apple.com> */ + +/* { dg-do compile } */ +/* { dg-options "-fpascal-strings -funsigned-char" } */ + +typedef unsigned char Str15[16]; + +Str15 ggg = "\p012345678901234"; +Str15 hhh = "0123456789012345"; /* { dg-error "initializer.string for array of chars is too long" } */ + +int foo(void) +{ + Str15 sss = "\p012345678901234"; + Str15 ttt = "0123456789012345"; /* { dg-error "initializer.string for array of chars is too long" } */ + + return 0; +} diff --git a/gcc/testsuite/g++.dg/preserve-PPC-CR.C b/gcc/testsuite/g++.dg/preserve-PPC-CR.C new file mode 100644 index 00000000000..38e76873ddd --- /dev/null +++ b/gcc/testsuite/g++.dg/preserve-PPC-CR.C @@ -0,0 +1,41 @@ +// APPLE LOCAL file preserve CR2 for save_world prologues +// This testcase failed at -O2 due to a missing EH note describing the PowerPC Condition Register. +// Thanks to Dale Johannesen. + +// { dg-do run } +// { dg-options "-fpascal-strings" } +#include <stdlib.h> +#include <stdio.h> +int tick = 1; +int caught_x = 1; +int h() { return 2; } +void f() +{ throw(3); } +extern int h(); +void ff() { + bool xx = h() == 0; + if ( !xx ) { + try { + f(); + } catch (float f) { + if (!xx) printf("%f\n", f); + } + } +} +int g(int y) +{ + bool x = h() != 0; + if ( x) { + try { + ff(); + } catch (int ex) { + // if (x) printf("%d\n", ex); + if (x) { tick++; caught_x = ex; } + }} +} +main() +{ + g(3); + if (tick != 2 || caught_x != 3) + abort(); +} |