Skip to content

R
riscv-gcc-1
Commit f737a52d by Janis Johnson Committed by Janis Johnson
Options

struct-by-value-3_x.c: Move common pieces to headers. 

2003-05-20  Janis Johnson  <janis187@us.ibm.com>

	* gcc.dg/compat/struct-by-value-3_x.c: Move common pieces to headers.
	* gcc.dg/compat/struct-by-value-3_y.c: Ditto.
	* gcc.dg/compat/struct-by-value-5_x.c: Ditto.
	* gcc.dg/compat/struct-by-value-5_y.c: Ditto.
	* gcc.dg/compat/struct-by-value-6_x.c: Ditto.
	* gcc.dg/compat/struct-by-value-6_y.c: Ditto.
	* gcc.dg/compat/struct-by-value-7_x.c Ditto.
	* gcc.dg/compat/struct-by-value-7_y.c Ditto.
	* gcc.dg/compat/small-struct-defs.h: New file.
	* gcc.dg/compat/small-struct-init.h: New file.
	* gcc.dg/compat/small-struct-check.h: New file.
	* gcc.dg/compat/fp-struct-defs.h: New file.
	* gcc.dg/compat/fp-struct-check.h: New file.
	* gcc.dg/compat/fp-struct-init.h: New file.
	* gcc.dg/compat/fp-struct-test-by-value-y.h: New file.
	* gcc.dg/compat/fp-struct-test-by-value-x.h: New file.

	* gcc.dg/compat/scalar-return-1_main.c: New file.
	* gcc.dg/compat/scalar-return-1_x.c: New file.
	* gcc.dg/compat/scalar-return-1_y.c: New file.
	* gcc.dg/compat/scalar-return-2_main.c: New file.
	* gcc.dg/compat/scalar-return-2_x.c: New file.
	* gcc.dg/compat/scalar-return-2_y.c: New file.
	* gcc.dg/compat/struct-return-3_main.c: New file.
	* gcc.dg/compat/struct-return-3_y.c: New file.
	* gcc.dg/compat/struct-return-3_x.c: New file.
	* gcc.dg/compat/struct-return-2_main.c: New file.
	* gcc.dg/compat/struct-return-2_x.c: New file.
	* gcc.dg/compat/struct-return-2_y.c: New file.

From-SVN: r67038
parent 5d34c8e9
Showing with 529 additions and 664 deletions
gcc/testsuite/ChangeLog
2003-05-20 Janis Johnson <janis187@us.ibm.com>
* gcc.dg/compat/struct-by-value-3_x.c: Move common pieces to headers.
* gcc.dg/compat/struct-by-value-3_y.c: Ditto.
* gcc.dg/compat/struct-by-value-5_x.c: Ditto.
* gcc.dg/compat/struct-by-value-5_y.c: Ditto.
* gcc.dg/compat/struct-by-value-6_x.c: Ditto.
* gcc.dg/compat/struct-by-value-6_y.c: Ditto.
* gcc.dg/compat/struct-by-value-7_x.c Ditto.
* gcc.dg/compat/struct-by-value-7_y.c Ditto.
* gcc.dg/compat/small-struct-defs.h: New file.
* gcc.dg/compat/small-struct-init.h: New file.
* gcc.dg/compat/small-struct-check.h: New file.
* gcc.dg/compat/fp-struct-defs.h: New file.
* gcc.dg/compat/fp-struct-check.h: New file.
* gcc.dg/compat/fp-struct-init.h: New file.
* gcc.dg/compat/fp-struct-test-by-value-y.h: New file.
* gcc.dg/compat/fp-struct-test-by-value-x.h: New file.
* gcc.dg/compat/scalar-return-1_main.c: New file.
* gcc.dg/compat/scalar-return-1_x.c: New file.
* gcc.dg/compat/scalar-return-1_y.c: New file.
* gcc.dg/compat/scalar-return-2_main.c: New file.
* gcc.dg/compat/scalar-return-2_x.c: New file.
* gcc.dg/compat/scalar-return-2_y.c: New file.
* gcc.dg/compat/struct-return-3_main.c: New file.
* gcc.dg/compat/struct-return-3_y.c: New file.
* gcc.dg/compat/struct-return-3_x.c: New file.
* gcc.dg/compat/struct-return-2_main.c: New file.
* gcc.dg/compat/struct-return-2_x.c: New file.
* gcc.dg/compat/struct-return-2_y.c: New file.
2003-05-19 Jakub Jelinek <jakub@redhat.com> 2003-05-19 Jakub Jelinek <jakub@redhat.com>
* gcc.dg/20030225-2.c: New test. * gcc.dg/20030225-2.c: New test.
......
gcc/testsuite/gcc.dg/compat/fp-struct-check.h 0 → 100644
/* Function definitions that are used by multiple tests. */
#define CHECKS(NAME,TYPEM) \
void checkS##NAME##1 (S##NAME##1 x, TYPEM y) \
{ if (x.a != y) { DEBUG_NL; DEBUG_NL; abort (); } } \
void checkS##NAME##2 (S##NAME##2 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 ) { DEBUG_NL; abort (); } } \
void checkS##NAME##3 (S##NAME##3 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 ) \
{ DEBUG_NL; abort (); } } \
void checkS##NAME##4 (S##NAME##4 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3) \
{ DEBUG_NL; abort (); } } \
void checkS##NAME##5 (S##NAME##5 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4) { DEBUG_NL; abort (); } } \
void checkS##NAME##6 (S##NAME##6 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5) { DEBUG_NL; abort (); } } \
void checkS##NAME##7 (S##NAME##7 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6) \
{ DEBUG_NL; abort (); } } \
void checkS##NAME##8 (S##NAME##8 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7) { DEBUG_NL; abort (); } } \
void checkS##NAME##9 (S##NAME##9 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8) { DEBUG_NL; abort (); } } \
void checkS##NAME##10 (S##NAME##10 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8 || x.j != y+9) \
{ DEBUG_NL; abort (); } } \
void checkS##NAME##11 (S##NAME##11 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8 || x.j != y+9 \
|| x.k != y+10) { DEBUG_NL; abort (); } } \
void checkS##NAME##12 (S##NAME##12 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8 || x.j != y+9 \
|| x.k != y+10 || x.l != y+11) { DEBUG_NL; abort (); } } \
void checkS##NAME##13 (S##NAME##13 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8 || x.j != y+9 \
|| x.k != y+10 || x.l != y+11 || x.m != y+12) \
{ DEBUG_NL; abort (); } } \
void checkS##NAME##14 (S##NAME##14 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8 || x.j != y+9 \
|| x.k != y+10 || x.l != y+11 || x.m != y+12 \
|| x.n != y+13) { DEBUG_NL; abort (); } } \
void checkS##NAME##15 (S##NAME##15 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8 || x.j != y+9 \
|| x.k != y+10 || x.l != y+11 || x.m != y+12 \
|| x.n != y+13 || x.o != y+14) { DEBUG_NL; abort (); } } \
void checkS##NAME##16 (S##NAME##16 x, TYPEM y) \
{ if (x.a != y || x.b != y+1 || x.c != y+2 || x.d != y+3 \
|| x.e != y+4 || x.f != y+5 || x.g != y+6 \
|| x.h != y+7 || x.i != y+8 || x.j != y+9 \
|| x.k != y+10 || x.l != y+11 || x.m != y+12 \
|| x.n != y+13 || x.o != y+14 || x.p != y+15) \
{ DEBUG_NL; abort (); } }
gcc/testsuite/gcc.dg/compat/fp-struct-defs.h 0 → 100644
/* Type definitions that are used by multiple tests. */
#define DEFS(NAME,TYPEM) \
typedef struct { TYPEM a; } S##NAME##1; \
typedef struct { TYPEM a; TYPEM b; } S##NAME##2; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; } S##NAME##3; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; } \
S##NAME##4; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; } \
S##NAME##5; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; } S##NAME##6; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; } S##NAME##7; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; } S##NAME##8; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; } \
S##NAME##9; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; } \
S##NAME##10; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; } S##NAME##11; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; } S##NAME##12; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; } S##NAME##13; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; } \
S##NAME##14; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; } \
S##NAME##15; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; \
TYPEM p; } S##NAME##16;
gcc/testsuite/gcc.dg/compat/fp-struct-init.h 0 → 100644
/* Function definitions that are used by multiple tests. */
#define INITS(NAME,TYPEM) \
void initS##NAME##1 (S##NAME##1 *p, TYPEM y) \
{ p->a = y; } \
void initS##NAME##2 (S##NAME##2 *p, TYPEM y) \
{ p->a = y; p->b = y+1; } \
void initS##NAME##3 (S##NAME##3 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; } \
void initS##NAME##4 (S##NAME##4 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; } \
void initS##NAME##5 (S##NAME##5 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; } \
void initS##NAME##6 (S##NAME##6 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; } \
void initS##NAME##7 (S##NAME##7 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; } \
void initS##NAME##8 (S##NAME##8 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; } \
void initS##NAME##9 (S##NAME##9 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; } \
void initS##NAME##10 (S##NAME##10 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; } \
void initS##NAME##11 (S##NAME##11 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; } \
void initS##NAME##12 (S##NAME##12 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; } \
void initS##NAME##13 (S##NAME##13 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; } \
void initS##NAME##14 (S##NAME##14 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; } \
void initS##NAME##15 (S##NAME##15 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; } \
void initS##NAME##16 (S##NAME##16 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; p->p = y+15; }
gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-x.h 0 → 100644
#define TEST(TYPE,MTYPE) \
TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE; \
TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE; \
TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE; \
TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE; \
\
extern void init##TYPE (TYPE *p, MTYPE x); \
extern void checkg##TYPE (void); \
extern void \
test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4, \
TYPE s5, TYPE s6, TYPE s7, TYPE s8, \
TYPE s9, TYPE s10, TYPE s11, TYPE s12, \
TYPE s13, TYPE s14, TYPE s15, TYPE s16); \
extern void testva##TYPE (int n, ...); \
\
void \
test2_##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4, \
TYPE s5, TYPE s6, TYPE s7, TYPE s8) \
{ \
test##TYPE (s1, g2s##TYPE, s2, g4s##TYPE, \
s3, g6s##TYPE, s4, g8s##TYPE, \
s5, g10s##TYPE, s6, g12s##TYPE, \
s7, g14s##TYPE, s8, g16s##TYPE); \
} \
\
void \
testit##TYPE (void) \
{ \
DEBUG_FPUTS (#TYPE); \
init##TYPE ( &g1s##TYPE, (MTYPE)1); \
init##TYPE ( &g2s##TYPE, (MTYPE)2); \
init##TYPE ( &g3s##TYPE, (MTYPE)3); \
init##TYPE ( &g4s##TYPE, (MTYPE)4); \
init##TYPE ( &g5s##TYPE, (MTYPE)5); \
init##TYPE ( &g6s##TYPE, (MTYPE)6); \
init##TYPE ( &g7s##TYPE, (MTYPE)7); \
init##TYPE ( &g8s##TYPE, (MTYPE)8); \
init##TYPE ( &g9s##TYPE, (MTYPE)9); \
init##TYPE (&g10s##TYPE, (MTYPE)10); \
init##TYPE (&g11s##TYPE, (MTYPE)11); \
init##TYPE (&g12s##TYPE, (MTYPE)12); \
init##TYPE (&g13s##TYPE, (MTYPE)13); \
init##TYPE (&g14s##TYPE, (MTYPE)14); \
init##TYPE (&g15s##TYPE, (MTYPE)15); \
init##TYPE (&g16s##TYPE, (MTYPE)16); \
checkg##TYPE (); \
DEBUG_FPUTS (" test"); \
test##TYPE (g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE, \
g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
DEBUG_FPUTS (" testva"); \
testva##TYPE (1, \
g1s##TYPE); \
testva##TYPE (2, \
g1s##TYPE, g2s##TYPE); \
testva##TYPE (3, \
g1s##TYPE, g2s##TYPE, g3s##TYPE); \
testva##TYPE (4, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE); \
testva##TYPE (5, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE); \
testva##TYPE (6, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE); \
testva##TYPE (7, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE); \
testva##TYPE (8, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE); \
testva##TYPE (9, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE); \
testva##TYPE (10, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE); \
testva##TYPE (11, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE, g11s##TYPE); \
testva##TYPE (12, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE); \
testva##TYPE (13, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE, \
g13s##TYPE); \
testva##TYPE (14, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE, \
g13s##TYPE, g14s##TYPE); \
testva##TYPE (15, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE, \
g13s##TYPE, g14s##TYPE, g15s##TYPE); \
testva##TYPE (16, \
g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE, \
g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE, \
g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE, \
g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE); \
DEBUG_FPUTS (" test2"); \
test2_##TYPE (g1s##TYPE, g3s##TYPE, g5s##TYPE, g7s##TYPE, \
g9s##TYPE, g11s##TYPE, g13s##TYPE, g15s##TYPE); \
DEBUG_NL; \
}
gcc/testsuite/gcc.dg/compat/fp-struct-test-by-value-y.h 0 → 100644
#define TEST(TYPE,TYPE2) \
extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE; \
extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE; \
extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE; \
extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE; \
\
extern void check##TYPE (TYPE x, TYPE2 y); \
\
void \
checkg##TYPE (void) \
{ \
check##TYPE ( g1s##TYPE, (TYPE2)1); \
check##TYPE ( g2s##TYPE, (TYPE2)2); \
check##TYPE ( g3s##TYPE, (TYPE2)3); \
check##TYPE ( g4s##TYPE, (TYPE2)4); \
check##TYPE ( g5s##TYPE, (TYPE2)5); \
check##TYPE ( g6s##TYPE, (TYPE2)6); \
check##TYPE ( g7s##TYPE, (TYPE2)7); \
check##TYPE ( g8s##TYPE, (TYPE2)8); \
check##TYPE ( g9s##TYPE, (TYPE2)9); \
check##TYPE ( g10s##TYPE, (TYPE2)10); \
check##TYPE ( g11s##TYPE, (TYPE2)11); \
check##TYPE ( g12s##TYPE, (TYPE2)12); \
check##TYPE ( g13s##TYPE, (TYPE2)13); \
check##TYPE ( g14s##TYPE, (TYPE2)14); \
check##TYPE ( g15s##TYPE, (TYPE2)15); \
check##TYPE ( g16s##TYPE, (TYPE2)16); \
} \
\
void \
test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4, \
TYPE s5, TYPE s6, TYPE s7, TYPE s8, \
TYPE s9, TYPE s10, TYPE s11, TYPE s12, \
TYPE s13, TYPE s14, TYPE s15, TYPE s16) \
{ \
DEBUG_DOT; \
check##TYPE (s1, (TYPE2)1); \
DEBUG_DOT; \
check##TYPE (s2, (TYPE2)2); \
DEBUG_DOT; \
check##TYPE (s3, (TYPE2)3); \
DEBUG_DOT; \
check##TYPE (s4, (TYPE2)4); \
DEBUG_DOT; \
check##TYPE (s5, (TYPE2)5); \
DEBUG_DOT; \
check##TYPE (s6, (TYPE2)6); \
DEBUG_DOT; \
check##TYPE (s7, (TYPE2)7); \
DEBUG_DOT; \
check##TYPE (s8, (TYPE2)8); \
DEBUG_DOT; \
check##TYPE (s9, (TYPE2)9); \
DEBUG_DOT; \
check##TYPE (s10, (TYPE2)10); \
DEBUG_DOT; \
check##TYPE (s11, (TYPE2)11); \
DEBUG_DOT; \
check##TYPE (s12, (TYPE2)12); \
DEBUG_DOT; \
check##TYPE (s13, (TYPE2)13); \
DEBUG_DOT; \
check##TYPE (s14, (TYPE2)14); \
DEBUG_DOT; \
check##TYPE (s15, (TYPE2)15); \
DEBUG_DOT; \
check##TYPE (s16, (TYPE2)16); \
} \
\
void \
testva##TYPE (int n, ...) \
{ \
int i; \
va_list ap; \
if (test_va) \
{ \
va_start (ap, n); \
for (i = 0; i < n; i++) \
{ \
TYPE t = va_arg (ap, TYPE); \
DEBUG_DOT; \
check##TYPE (t, (TYPE2)i+1); \
} \
va_end (ap); \
} \
}
gcc/testsuite/gcc.dg/compat/small-struct-check.h 0 → 100644
/* Function definitions that are used by multiple tests. */
void checkSc (Sc x, int i) { if (x.c != (char)i) { DEBUG_NL; abort (); } }
void checkSs (Ss x, int i) { if (x.s != i) { DEBUG_NL; abort (); } }
void checkSi (Si x, int i) { if (x.i != i) { DEBUG_NL; abort (); } }
void checkSsc (Ssc x, int i)
{ if (x.s != i || x.c != (char)i+1) { DEBUG_NL; abort (); } }
void checkScs (Scs x, int i)
{ if (x.c != (char)i || x.s != i+1) { DEBUG_NL; abort (); } }
void checkSsi (Ssi x, int i)
{ if (x.s != i || x.i != i+1) { DEBUG_NL; abort (); } }
void checkSis (Sis x, int i)
{ if (x.i != i || x.s != i+1) { DEBUG_NL; abort (); } }
void checkSic (Sic x, int i)
{ if (x.i != i || x.c != (char)i+1) { DEBUG_NL; abort (); } }
void checkSci (Sci x, int i)
{ if (x.c != (char)i || x.i != i+1) { DEBUG_NL; abort (); } }
void checkScsi (Scsi x, int i)
{ if (x.c != (char)i || x.s != i+1 || x.i != i+2) { DEBUG_NL; abort (); } }
void checkScis (Scis x, int i)
{ if (x.c != (char)i || x.i != i+1 || x.s != i+2) { DEBUG_NL; abort (); } }
void checkSsci (Ssci x, int i)
{ if (x.s != i || x.c != (char)i+1 || x.i != i+2) { DEBUG_NL; abort (); } }
void checkSsic (Ssic x, int i)
{ if (x.s != i || x.i != i+1 || x.c != (char)i+2) { DEBUG_NL; abort (); } }
void checkSisc (Sisc x, int i)
{ if (x.i != i || x.s != i+1 || x.c != (char)i+2) { DEBUG_NL; abort (); } }
void checkSics (Sics x, int i)
{ if (x.i != i || x.c != (char)i+1 || x.s != i+2) { DEBUG_NL; abort (); } }
gcc/testsuite/gcc.dg/compat/small-struct-defs.h 0 → 100644
/* Type definitions that are used by multiple tests. */
typedef struct { char c; } Sc;
typedef struct { short s; } Ss;
typedef struct { int i; } Si;
typedef struct { short s; char c; } Ssc;
typedef struct { char c; short s; } Scs;
typedef struct { int i; char c; } Sic;
typedef struct { char c; int i; } Sci;
typedef struct { short s; int i; } Ssi;
typedef struct { int i; short s; } Sis;
typedef struct { char c; short s; int i; } Scsi;
typedef struct { char c; int i; short s; } Scis;
typedef struct { short s; char c; int i; } Ssci;
typedef struct { short s; int i; char c; } Ssic;
typedef struct { int i; short s; char c; } Sisc;
typedef struct { int i; char c; short s; } Sics;
gcc/testsuite/gcc.dg/compat/small-struct-init.h 0 → 100644
/* Function definitions that are used by multiple tests. */
void initSc (Sc *p, int i) { p->c = (char)i; }
void initSs (Ss *p, int i) { p->s = i; }
void initSi (Si *p, int i) { p->i = i; }
void initSsc (Ssc *p, int i) { p->s = i; p->c = (char)i+1; }
void initScs (Scs *p, int i) { p->c = (char)i; p->s = i+1; }
void initSsi (Ssi *p, int i) { p->s = i; p->i = i+1; }
void initSis (Sis *p, int i) { p->i = i; p->s = i+1; }
void initSic (Sic *p, int i) { p->i = i; p->c = (char)i+1; }
void initSci (Sci *p, int i) { p->c = (char)i; p->i = i+1; }
void initScsi (Scsi *p, int i) { p->c = (char)i; p->s = i+1; p->i = i+2; }
void initScis (Scis *p, int i) { p->c = (char)i; p->i = i+1; p->s = i+2; }
void initSsci (Ssci *p, int i) { p->s = i; p->c = (char)i+1; p->i = i+2; }
void initSsic (Ssic *p, int i) { p->s = i; p->i = i+1; p->c = (char)i+2; }
void initSisc (Sisc *p, int i) { p->i = i; p->s = i+1; p->c = (char)i+2; }
void initSics (Sics *p, int i) { p->i = i; p->c = (char)i+1; p->s = i+2; }
gcc/testsuite/gcc.dg/compat/struct-by-value-3_x.c
...@@ -123,51 +123,10 @@ testit##TYPE (void) \ ...@@ -123,51 +123,10 @@ testit##TYPE (void) \
DEBUG_NL; \ DEBUG_NL; \
} }
typedef struct { char c; } Sc;
typedef struct { short s; } Ss;
typedef struct { int i; } Si;
typedef struct { short s; char c; } Ssc;
typedef struct { char c; short s; } Scs;
typedef struct { int i; char c; } Sic;
typedef struct { char c; int i; } Sci;
typedef struct { short s; int i; } Ssi;
typedef struct { int i; short s; } Sis;
typedef struct { char c; short s; int i; } Scsi;
typedef struct { char c; int i; short s; } Scis;
typedef struct { short s; char c; int i; } Ssci;
typedef struct { short s; int i; char c; } Ssic;
typedef struct { int i; short s; char c; } Sisc;
typedef struct { int i; char c; short s; } Sics;
extern void abort (void); extern void abort (void);
void checkSc (Sc x, int i) { if (x.c != (char)i) { DEBUG_NL; abort (); } } #include "small-struct-defs.h"
void checkSs (Ss x, int i) { if (x.s != i) { DEBUG_NL; abort (); } } #include "small-struct-check.h"
void checkSi (Si x, int i) { if (x.i != i) { DEBUG_NL; abort (); } }
void checkSsc (Ssc x, int i)
{ if (x.s != i || x.c != (char)i+1) { DEBUG_NL; abort (); } }
void checkScs (Scs x, int i)
{ if (x.c != (char)i || x.s != i+1) { DEBUG_NL; abort (); } }
void checkSsi (Ssi x, int i)
{ if (x.s != i || x.i != i+1) { DEBUG_NL; abort (); } }
void checkSis (Sis x, int i)
{ if (x.i != i || x.s != i+1) { DEBUG_NL; abort (); } }
void checkSic (Sic x, int i)
{ if (x.i != i || x.c != (char)i+1) { DEBUG_NL; abort (); } }
void checkSci (Sci x, int i)
{ if (x.c != (char)i || x.i != i+1) { DEBUG_NL; abort (); } }
void checkScsi (Scsi x, int i)
{ if (x.c != (char)i || x.s != i+1 || x.i != i+2) { DEBUG_NL; abort (); } }
void checkScis (Scis x, int i)
{ if (x.c != (char)i || x.i != i+1 || x.s != i+2) { DEBUG_NL; abort (); } }
void checkSsci (Ssci x, int i)
{ if (x.s != i || x.c != (char)i+1 || x.i != i+2) { DEBUG_NL; abort (); } }
void checkSsic (Ssic x, int i)
{ if (x.s != i || x.i != i+1 || x.c != (char)i+2) { DEBUG_NL; abort (); } }
void checkSisc (Sisc x, int i)
{ if (x.i != i || x.s != i+1 || x.c != (char)i+2) { DEBUG_NL; abort (); } }
void checkSics (Sics x, int i)
{ if (x.i != i || x.c != (char)i+1 || x.s != i+2) { DEBUG_NL; abort (); } }
T(Sc) T(Sc)
T(Ss) T(Ss)
......
gcc/testsuite/gcc.dg/compat/struct-by-value-3_y.c
...@@ -18,21 +18,7 @@ const int test_va = 0; ...@@ -18,21 +18,7 @@ const int test_va = 0;
const int test_va = 1; const int test_va = 1;
#endif #endif
typedef struct { char c; } Sc; #include "small-struct-defs.h"
typedef struct { short s; } Ss;
typedef struct { int i; } Si;
typedef struct { short s; char c; } Ssc;
typedef struct { char c; short s; } Scs;
typedef struct { int i; char c; } Sic;
typedef struct { char c; int i; } Sci;
typedef struct { short s; int i; } Ssi;
typedef struct { int i; short s; } Sis;
typedef struct { char c; short s; int i; } Scsi;
typedef struct { char c; int i; short s; } Scis;
typedef struct { short s; char c; int i; } Ssci;
typedef struct { short s; int i; char c; } Ssic;
typedef struct { int i; short s; char c; } Sisc;
typedef struct { int i; char c; short s; } Sics;
extern void checkSc (Sc x, int i); extern void checkSc (Sc x, int i);
extern void checkSs (Ss x, int i); extern void checkSs (Ss x, int i);
...@@ -50,21 +36,7 @@ extern void checkSsic (Ssic x, int i); ...@@ -50,21 +36,7 @@ extern void checkSsic (Ssic x, int i);
extern void checkSisc (Sisc x, int i); extern void checkSisc (Sisc x, int i);
extern void checkSics (Sics x, int i); extern void checkSics (Sics x, int i);
void initSc (Sc *p, int i) { p->c = (char)i; } #include "small-struct-init.h"
void initSs (Ss *p, int i) { p->s = i; }
void initSi (Si *p, int i) { p->i = i; }
void initSsc (Ssc *p, int i) { p->s = i; p->c = (char)i+1; }
void initScs (Scs *p, int i) { p->c = (char)i; p->s = i+1; }
void initSsi (Ssi *p, int i) { p->s = i; p->i = i+1; }
void initSis (Sis *p, int i) { p->i = i; p->s = i+1; }
void initSic (Sic *p, int i) { p->i = i; p->c = (char)i+1; }
void initSci (Sci *p, int i) { p->c = (char)i; p->i = i+1; }
void initScsi (Scsi *p, int i) { p->c = (char)i; p->s = i+1; p->i = i+2; }
void initScis (Scis *p, int i) { p->c = (char)i; p->i = i+1; p->s = i+2; }
void initSsci (Ssci *p, int i) { p->s = i; p->c = (char)i+1; p->i = i+2; }
void initSsic (Ssic *p, int i) { p->s = i; p->i = i+1; p->c = (char)i+2; }
void initSisc (Sisc *p, int i) { p->i = i; p->s = i+1; p->c = (char)i+2; }
void initSics (Sics *p, int i) { p->i = i; p->c = (char)i+1; p->s = i+2; }
#define T(TYPE) \ #define T(TYPE) \
extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE; \ extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE; \
......
gcc/testsuite/gcc.dg/compat/struct-by-value-5_y.c
...@@ -18,202 +18,26 @@ const int test_va = 0; ...@@ -18,202 +18,26 @@ const int test_va = 0;
const int test_va = 1; const int test_va = 1;
#endif #endif
#define X(NAME,TYPEM) \ #include "fp-struct-defs.h"
typedef struct { TYPEM a; } S##NAME##1; \ #include "fp-struct-init.h"
typedef struct { TYPEM a; TYPEM b; } S##NAME##2; \ #include "fp-struct-test-by-value-y.h"
typedef struct { TYPEM a; TYPEM b; TYPEM c; } S##NAME##3; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; } \
S##NAME##4; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; } \
S##NAME##5; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; } S##NAME##6; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; } S##NAME##7; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; } S##NAME##8; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; } \
S##NAME##9; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; } \
S##NAME##10; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; } S##NAME##11; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; } S##NAME##12; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; } S##NAME##13; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; } \
S##NAME##14; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; } \
S##NAME##15; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; \
TYPEM p; } S##NAME##16; \
\
void initS##NAME##1 (S##NAME##1 *p, TYPEM y) \
{ p->a = y; } \
void initS##NAME##2 (S##NAME##2 *p, TYPEM y) \
{ p->a = y; p->b = y+1; } \
void initS##NAME##3 (S##NAME##3 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; } \
void initS##NAME##4 (S##NAME##4 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; } \
void initS##NAME##5 (S##NAME##5 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; } \
void initS##NAME##6 (S##NAME##6 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; } \
void initS##NAME##7 (S##NAME##7 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; } \
void initS##NAME##8 (S##NAME##8 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; } \
void initS##NAME##9 (S##NAME##9 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; } \
void initS##NAME##10 (S##NAME##10 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; } \
void initS##NAME##11 (S##NAME##11 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; } \
void initS##NAME##12 (S##NAME##12 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; } \
void initS##NAME##13 (S##NAME##13 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; } \
void initS##NAME##14 (S##NAME##14 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; } \
void initS##NAME##15 (S##NAME##15 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; } \
void initS##NAME##16 (S##NAME##16 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; p->p = y+15; }
#define T(TYPE,TYPE2) \ DEFS(f,float)
extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE; \ INITS(f, float)
extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE; \
extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE; \
extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE; \
\
extern void check##TYPE (TYPE x, TYPE2 y); \
\
void \
checkg##TYPE (void) \
{ \
check##TYPE ( g1s##TYPE, (TYPE2)1); \
check##TYPE ( g2s##TYPE, (TYPE2)2); \
check##TYPE ( g3s##TYPE, (TYPE2)3); \
check##TYPE ( g4s##TYPE, (TYPE2)4); \
check##TYPE ( g5s##TYPE, (TYPE2)5); \
check##TYPE ( g6s##TYPE, (TYPE2)6); \
check##TYPE ( g7s##TYPE, (TYPE2)7); \
check##TYPE ( g8s##TYPE, (TYPE2)8); \
check##TYPE ( g9s##TYPE, (TYPE2)9); \
check##TYPE ( g10s##TYPE, (TYPE2)10); \
check##TYPE ( g11s##TYPE, (TYPE2)11); \
check##TYPE ( g12s##TYPE, (TYPE2)12); \
check##TYPE ( g13s##TYPE, (TYPE2)13); \
check##TYPE ( g14s##TYPE, (TYPE2)14); \
check##TYPE ( g15s##TYPE, (TYPE2)15); \
check##TYPE ( g16s##TYPE, (TYPE2)16); \
} \
\
void \
test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4, \
TYPE s5, TYPE s6, TYPE s7, TYPE s8, \
TYPE s9, TYPE s10, TYPE s11, TYPE s12, \
TYPE s13, TYPE s14, TYPE s15, TYPE s16) \
{ \
DEBUG_DOT; \
check##TYPE (s1, (TYPE2)1); \
DEBUG_DOT; \
check##TYPE (s2, (TYPE2)2); \
DEBUG_DOT; \
check##TYPE (s3, (TYPE2)3); \
DEBUG_DOT; \
check##TYPE (s4, (TYPE2)4); \
DEBUG_DOT; \
check##TYPE (s5, (TYPE2)5); \
DEBUG_DOT; \
check##TYPE (s6, (TYPE2)6); \
DEBUG_DOT; \
check##TYPE (s7, (TYPE2)7); \
DEBUG_DOT; \
check##TYPE (s8, (TYPE2)8); \
DEBUG_DOT; \
check##TYPE (s9, (TYPE2)9); \
DEBUG_DOT; \
check##TYPE (s10, (TYPE2)10); \
DEBUG_DOT; \
check##TYPE (s11, (TYPE2)11); \
DEBUG_DOT; \
check##TYPE (s12, (TYPE2)12); \
DEBUG_DOT; \
check##TYPE (s13, (TYPE2)13); \
DEBUG_DOT; \
check##TYPE (s14, (TYPE2)14); \
DEBUG_DOT; \
check##TYPE (s15, (TYPE2)15); \
DEBUG_DOT; \
check##TYPE (s16, (TYPE2)16); \
} \
\
void \
testva##TYPE (int n, ...) \
{ \
int i; \
va_list ap; \
if (test_va) \
{ \
va_start (ap, n); \
for (i = 0; i < n; i++) \
{ \
TYPE t = va_arg (ap, TYPE); \
DEBUG_DOT; \
check##TYPE (t, (TYPE2)i+1); \
} \
va_end (ap); \
} \
}
X(f, float) TEST(Sf1, float)
TEST(Sf2, float)
T(Sf1, float) TEST(Sf3, float)
T(Sf2, float) TEST(Sf4, float)
T(Sf3, float) TEST(Sf5, float)
T(Sf4, float) TEST(Sf6, float)
T(Sf5, float) TEST(Sf7, float)
T(Sf6, float) TEST(Sf8, float)
T(Sf7, float) TEST(Sf9, float)
T(Sf8, float) TEST(Sf10, float)
T(Sf9, float) TEST(Sf11, float)
T(Sf10, float) TEST(Sf12, float)
T(Sf11, float) TEST(Sf13, float)
T(Sf12, float) TEST(Sf14, float)
T(Sf13, float) TEST(Sf15, float)
T(Sf14, float) TEST(Sf16, float)
T(Sf15, float)
T(Sf16, float)
gcc/testsuite/gcc.dg/compat/struct-by-value-6_y.c
...@@ -18,202 +18,26 @@ const int test_va = 0; ...@@ -18,202 +18,26 @@ const int test_va = 0;
const int test_va = 1; const int test_va = 1;
#endif #endif
#define X(NAME,TYPEM) \ #include "fp-struct-defs.h"
typedef struct { TYPEM a; } S##NAME##1; \ #include "fp-struct-init.h"
typedef struct { TYPEM a; TYPEM b; } S##NAME##2; \ #include "fp-struct-test-by-value-y.h"
typedef struct { TYPEM a; TYPEM b; TYPEM c; } S##NAME##3; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; } \
S##NAME##4; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; } \
S##NAME##5; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; } S##NAME##6; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; } S##NAME##7; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; } S##NAME##8; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; } \
S##NAME##9; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; } \
S##NAME##10; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; } S##NAME##11; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; } S##NAME##12; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; } S##NAME##13; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; } \
S##NAME##14; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; } \
S##NAME##15; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; \
TYPEM p; } S##NAME##16; \
\
void initS##NAME##1 (S##NAME##1 *p, TYPEM y) \
{ p->a = y; } \
void initS##NAME##2 (S##NAME##2 *p, TYPEM y) \
{ p->a = y; p->b = y+1; } \
void initS##NAME##3 (S##NAME##3 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; } \
void initS##NAME##4 (S##NAME##4 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; } \
void initS##NAME##5 (S##NAME##5 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; } \
void initS##NAME##6 (S##NAME##6 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; } \
void initS##NAME##7 (S##NAME##7 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; } \
void initS##NAME##8 (S##NAME##8 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; } \
void initS##NAME##9 (S##NAME##9 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; } \
void initS##NAME##10 (S##NAME##10 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; } \
void initS##NAME##11 (S##NAME##11 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; } \
void initS##NAME##12 (S##NAME##12 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; } \
void initS##NAME##13 (S##NAME##13 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; } \
void initS##NAME##14 (S##NAME##14 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; } \
void initS##NAME##15 (S##NAME##15 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; } \
void initS##NAME##16 (S##NAME##16 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; p->p = y+15; }
#define T(TYPE,TYPE2) \ DEFS(d, double)
extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE; \ INITS(d, double)
extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE; \
extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE; \
extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE; \
\
extern void check##TYPE (TYPE x, TYPE2 y); \
\
void \
checkg##TYPE (void) \
{ \
check##TYPE ( g1s##TYPE, (TYPE2)1); \
check##TYPE ( g2s##TYPE, (TYPE2)2); \
check##TYPE ( g3s##TYPE, (TYPE2)3); \
check##TYPE ( g4s##TYPE, (TYPE2)4); \
check##TYPE ( g5s##TYPE, (TYPE2)5); \
check##TYPE ( g6s##TYPE, (TYPE2)6); \
check##TYPE ( g7s##TYPE, (TYPE2)7); \
check##TYPE ( g8s##TYPE, (TYPE2)8); \
check##TYPE ( g9s##TYPE, (TYPE2)9); \
check##TYPE ( g10s##TYPE, (TYPE2)10); \
check##TYPE ( g11s##TYPE, (TYPE2)11); \
check##TYPE ( g12s##TYPE, (TYPE2)12); \
check##TYPE ( g13s##TYPE, (TYPE2)13); \
check##TYPE ( g14s##TYPE, (TYPE2)14); \
check##TYPE ( g15s##TYPE, (TYPE2)15); \
check##TYPE ( g16s##TYPE, (TYPE2)16); \
} \
\
void \
test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4, \
TYPE s5, TYPE s6, TYPE s7, TYPE s8, \
TYPE s9, TYPE s10, TYPE s11, TYPE s12, \
TYPE s13, TYPE s14, TYPE s15, TYPE s16) \
{ \
DEBUG_DOT; \
check##TYPE (s1, (TYPE2)1); \
DEBUG_DOT; \
check##TYPE (s2, (TYPE2)2); \
DEBUG_DOT; \
check##TYPE (s3, (TYPE2)3); \
DEBUG_DOT; \
check##TYPE (s4, (TYPE2)4); \
DEBUG_DOT; \
check##TYPE (s5, (TYPE2)5); \
DEBUG_DOT; \
check##TYPE (s6, (TYPE2)6); \
DEBUG_DOT; \
check##TYPE (s7, (TYPE2)7); \
DEBUG_DOT; \
check##TYPE (s8, (TYPE2)8); \
DEBUG_DOT; \
check##TYPE (s9, (TYPE2)9); \
DEBUG_DOT; \
check##TYPE (s10, (TYPE2)10); \
DEBUG_DOT; \
check##TYPE (s11, (TYPE2)11); \
DEBUG_DOT; \
check##TYPE (s12, (TYPE2)12); \
DEBUG_DOT; \
check##TYPE (s13, (TYPE2)13); \
DEBUG_DOT; \
check##TYPE (s14, (TYPE2)14); \
DEBUG_DOT; \
check##TYPE (s15, (TYPE2)15); \
DEBUG_DOT; \
check##TYPE (s16, (TYPE2)16); \
} \
\
void \
testva##TYPE (int n, ...) \
{ \
int i; \
va_list ap; \
if (test_va) \
{ \
va_start (ap, n); \
for (i = 0; i < n; i++) \
{ \
TYPE t = va_arg (ap, TYPE); \
DEBUG_DOT; \
check##TYPE (t, (TYPE2)i+1); \
} \
va_end (ap); \
} \
}
X(d, double) TEST(Sd1, double)
TEST(Sd2, double)
T(Sd1, double) TEST(Sd3, double)
T(Sd2, double) TEST(Sd4, double)
T(Sd3, double) TEST(Sd5, double)
T(Sd4, double) TEST(Sd6, double)
T(Sd5, double) TEST(Sd7, double)
T(Sd6, double) TEST(Sd8, double)
T(Sd7, double) TEST(Sd9, double)
T(Sd8, double) TEST(Sd10, double)
T(Sd9, double) TEST(Sd11, double)
T(Sd10, double) TEST(Sd12, double)
T(Sd11, double) TEST(Sd13, double)
T(Sd12, double) TEST(Sd14, double)
T(Sd13, double) TEST(Sd15, double)
T(Sd14, double) TEST(Sd16, double)
T(Sd15, double)
T(Sd16, double)
gcc/testsuite/gcc.dg/compat/struct-by-value-7_y.c
...@@ -18,202 +18,26 @@ const int test_va = 0; ...@@ -18,202 +18,26 @@ const int test_va = 0;
const int test_va = 1; const int test_va = 1;
#endif #endif
#define X(NAME,TYPEM) \ #include "fp-struct-defs.h"
typedef struct { TYPEM a; } S##NAME##1; \ #include "fp-struct-init.h"
typedef struct { TYPEM a; TYPEM b; } S##NAME##2; \ #include "fp-struct-test-by-value-y.h"
typedef struct { TYPEM a; TYPEM b; TYPEM c; } S##NAME##3; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; } \
S##NAME##4; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; } \
S##NAME##5; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; } S##NAME##6; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; } S##NAME##7; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; } S##NAME##8; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; } \
S##NAME##9; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; } \
S##NAME##10; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; } S##NAME##11; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; } S##NAME##12; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; } S##NAME##13; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; } \
S##NAME##14; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; } \
S##NAME##15; \
typedef struct { TYPEM a; TYPEM b; TYPEM c; TYPEM d; TYPEM e; \
TYPEM f; TYPEM g; TYPEM h; TYPEM i; TYPEM j; \
TYPEM k; TYPEM l; TYPEM m; TYPEM n; TYPEM o; \
TYPEM p; } S##NAME##16; \
\
void initS##NAME##1 (S##NAME##1 *p, TYPEM y) \
{ p->a = y; } \
void initS##NAME##2 (S##NAME##2 *p, TYPEM y) \
{ p->a = y; p->b = y+1; } \
void initS##NAME##3 (S##NAME##3 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; } \
void initS##NAME##4 (S##NAME##4 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; } \
void initS##NAME##5 (S##NAME##5 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; } \
void initS##NAME##6 (S##NAME##6 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; } \
void initS##NAME##7 (S##NAME##7 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; } \
void initS##NAME##8 (S##NAME##8 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; } \
void initS##NAME##9 (S##NAME##9 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; } \
void initS##NAME##10 (S##NAME##10 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; } \
void initS##NAME##11 (S##NAME##11 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; } \
void initS##NAME##12 (S##NAME##12 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; } \
void initS##NAME##13 (S##NAME##13 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; } \
void initS##NAME##14 (S##NAME##14 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; } \
void initS##NAME##15 (S##NAME##15 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; } \
void initS##NAME##16 (S##NAME##16 *p, TYPEM y) \
{ p->a = y; p->b = y+1; p->c = y+2; p->d = y+3; p->e = y+4; \
p->f = y+5; p->g = y+6; p->h = y+7; p->i = y+8; p->j = y+9; \
p->k = y+10; p->l = y+11; p->m = y+12; p->n = y+13; \
p->o = y+14; p->p = y+15; }
#define T(TYPE,TYPE2) \ DEFS(ld, long double)
extern TYPE g1s##TYPE, g2s##TYPE, g3s##TYPE, g4s##TYPE; \ INITS(ld, long double)
extern TYPE g5s##TYPE, g6s##TYPE, g7s##TYPE, g8s##TYPE; \
extern TYPE g9s##TYPE, g10s##TYPE, g11s##TYPE, g12s##TYPE; \
extern TYPE g13s##TYPE, g14s##TYPE, g15s##TYPE, g16s##TYPE; \
\
extern void check##TYPE (TYPE x, TYPE2 y); \
\
void \
checkg##TYPE (void) \
{ \
check##TYPE ( g1s##TYPE, (TYPE2)1); \
check##TYPE ( g2s##TYPE, (TYPE2)2); \
check##TYPE ( g3s##TYPE, (TYPE2)3); \
check##TYPE ( g4s##TYPE, (TYPE2)4); \
check##TYPE ( g5s##TYPE, (TYPE2)5); \
check##TYPE ( g6s##TYPE, (TYPE2)6); \
check##TYPE ( g7s##TYPE, (TYPE2)7); \
check##TYPE ( g8s##TYPE, (TYPE2)8); \
check##TYPE ( g9s##TYPE, (TYPE2)9); \
check##TYPE ( g10s##TYPE, (TYPE2)10); \
check##TYPE ( g11s##TYPE, (TYPE2)11); \
check##TYPE ( g12s##TYPE, (TYPE2)12); \
check##TYPE ( g13s##TYPE, (TYPE2)13); \
check##TYPE ( g14s##TYPE, (TYPE2)14); \
check##TYPE ( g15s##TYPE, (TYPE2)15); \
check##TYPE ( g16s##TYPE, (TYPE2)16); \
} \
\
void \
test##TYPE (TYPE s1, TYPE s2, TYPE s3, TYPE s4, \
TYPE s5, TYPE s6, TYPE s7, TYPE s8, \
TYPE s9, TYPE s10, TYPE s11, TYPE s12, \
TYPE s13, TYPE s14, TYPE s15, TYPE s16) \
{ \
DEBUG_DOT; \
check##TYPE (s1, (TYPE2)1); \
DEBUG_DOT; \
check##TYPE (s2, (TYPE2)2); \
DEBUG_DOT; \
check##TYPE (s3, (TYPE2)3); \
DEBUG_DOT; \
check##TYPE (s4, (TYPE2)4); \
DEBUG_DOT; \
check##TYPE (s5, (TYPE2)5); \
DEBUG_DOT; \
check##TYPE (s6, (TYPE2)6); \
DEBUG_DOT; \
check##TYPE (s7, (TYPE2)7); \
DEBUG_DOT; \
check##TYPE (s8, (TYPE2)8); \
DEBUG_DOT; \
check##TYPE (s9, (TYPE2)9); \
DEBUG_DOT; \
check##TYPE (s10, (TYPE2)10); \
DEBUG_DOT; \
check##TYPE (s11, (TYPE2)11); \
DEBUG_DOT; \
check##TYPE (s12, (TYPE2)12); \
DEBUG_DOT; \
check##TYPE (s13, (TYPE2)13); \
DEBUG_DOT; \
check##TYPE (s14, (TYPE2)14); \
DEBUG_DOT; \
check##TYPE (s15, (TYPE2)15); \
DEBUG_DOT; \
check##TYPE (s16, (TYPE2)16); \
} \
\
void \
testva##TYPE (int n, ...) \
{ \
int i; \
va_list ap; \
if (test_va) \
{ \
va_start (ap, n); \
for (i = 0; i < n; i++) \
{ \
TYPE t = va_arg (ap, TYPE); \
DEBUG_DOT; \
check##TYPE (t, (TYPE2)i+1); \
} \
va_end (ap); \
} \
}
X(ld, long double) TEST(Sld1, long double)
TEST(Sld2, long double)
T(Sld1, long double) TEST(Sld3, long double)
T(Sld2, long double) TEST(Sld4, long double)
T(Sld3, long double) TEST(Sld5, long double)
T(Sld4, long double) TEST(Sld6, long double)
T(Sld5, long double) TEST(Sld7, long double)
T(Sld6, long double) TEST(Sld8, long double)
T(Sld7, long double) TEST(Sld9, long double)
T(Sld8, long double) TEST(Sld10, long double)
T(Sld9, long double) TEST(Sld11, long double)
T(Sld10, long double) TEST(Sld12, long double)
T(Sld11, long double) TEST(Sld13, long double)
T(Sld12, long double) TEST(Sld14, long double)
T(Sld13, long double) TEST(Sld15, long double)
T(Sld14, long double) TEST(Sld16, long double)
T(Sld15, long double)
T(Sld16, long double)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment