procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

testsuite: Expand coverage for `__builtin_memset' with 0

Browse source 
Expand coverage for `__builtin_memset' for the special case of clearing
a block, primarily for "setmemM" block set pattern, though with smaller
sizes open-coded sequences may be produced instead.

This verifies block sizes in bytes from 1 to 64 across byte alignments
of 1, 2, 4, 8 and byte misalignments within from 0 up to 7 (there's some
redundancy there for the sake of simplicity of the test case), making
sure all the intended area is cleared and no data is changed outside it.

These choice of the ranges for the parameters has come from the Alpha
backend, whose "setmemM" pattern has various corner cases related to
base alignment and the misalignment within.

The test case has turned invaluable in verifying changes to the Alpha
backend, but functionality covered is generic, so I have concluded this
test qualifies for generic verification and does not have to be limited
to the Alpha-specific subset of the testsuite.

Just as with `__builtin_memcpy' tests this code turned out to require
quite a lot of time to compile, although a bit less than the former.

Example compilation times with reasonably fast POWER9@2.166GHz at `-O2'
optimization and GCC built at `-O2' for various targets:

mips-linux-gnu:        19s
vax-netbsdelf:         27s
alphaev56-linux-gnu:   30s
alpha-linux-gnu:       31s
powerpc64le-linux-gnu: 47s

With GCC built at `-O0':

alphaev56-linux-gnu: 2m59s
alpha-linux-gnu:     3m06s

I have therefore set the timeout factor accordingly so as to take slower
test hosts into account.

	gcc/testsuite/
	* gcc.c-torture/execute/memclr.c: New file.
This commit is contained in:
Maciej W. Rozycki 2024-12-25 22:23:39 +00:00
parent 46cb538cc0
commit 5a089689a2
1 changed files with 233 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

233
gcc/testsuite/gcc.c-torture/execute/memclr.c Normal file
View file

@ -0,0 +1,233 @@
/* { dg-require-effective-target run_expensive_tests } */
/* { dg-timeout-factor 4 } */
/* { dg-skip-if "memory full + time hog" { "avr-*-*" } } */
typedef unsigned int __attribute__ ((mode (QI))) int08_t;
typedef unsigned int __attribute__ ((mode (HI))) int16_t;
typedef unsigned int __attribute__ ((mode (SI))) int32_t;
typedef unsigned int __attribute__ ((mode (DI))) int64_t;
typedef union
{
int08_t v[88];
}
a1_t;
typedef union
{
int08_t v[88];
int16_t a;
}
a2_t;
typedef union
{
int08_t v[88];
int32_t a;
}
a4_t;
typedef union
{
int08_t v[88];
int64_t a;
}
a8_t;
#define MEMCLR_DEFINE_ONE(align, offset, count) \
static void __attribute__ ((noinline)) \
memclr_check_one_ ## align ## offset ## count (void) \
{ \
static a ## align ## _t dst = {{ [0 ... 87] = 0xaa }}; \
int i; \
\
__builtin_memset (dst.v + 8 + offset, 0, count); \
asm ("" : : : "memory"); \
for (i = 0; i < 8 + offset; i++) \
if (dst.v[i] != 0xaa) \
__builtin_abort (); \
for (; i < 8 + offset + count; i++) \
if (dst.v[i] != 0x00) \
__builtin_abort (); \
for (; i < sizeof (dst.v); i++) \
if (dst.v[i] != 0xaa) \
__builtin_abort (); \
}
#define MEMCLR_DEFINE_ONE_ALIGN_OFFSET(align, offset) \
MEMCLR_DEFINE_ONE (align, offset, 1) \
MEMCLR_DEFINE_ONE (align, offset, 2) \
MEMCLR_DEFINE_ONE (align, offset, 3) \
MEMCLR_DEFINE_ONE (align, offset, 4) \
MEMCLR_DEFINE_ONE (align, offset, 5) \
MEMCLR_DEFINE_ONE (align, offset, 6) \
MEMCLR_DEFINE_ONE (align, offset, 7) \
MEMCLR_DEFINE_ONE (align, offset, 8) \
MEMCLR_DEFINE_ONE (align, offset, 9) \
MEMCLR_DEFINE_ONE (align, offset, 10) \
MEMCLR_DEFINE_ONE (align, offset, 11) \
MEMCLR_DEFINE_ONE (align, offset, 12) \
MEMCLR_DEFINE_ONE (align, offset, 13) \
MEMCLR_DEFINE_ONE (align, offset, 14) \
MEMCLR_DEFINE_ONE (align, offset, 15) \
MEMCLR_DEFINE_ONE (align, offset, 16) \
MEMCLR_DEFINE_ONE (align, offset, 17) \
MEMCLR_DEFINE_ONE (align, offset, 18) \
MEMCLR_DEFINE_ONE (align, offset, 19) \
MEMCLR_DEFINE_ONE (align, offset, 20) \
MEMCLR_DEFINE_ONE (align, offset, 21) \
MEMCLR_DEFINE_ONE (align, offset, 22) \
MEMCLR_DEFINE_ONE (align, offset, 23) \
MEMCLR_DEFINE_ONE (align, offset, 24) \
MEMCLR_DEFINE_ONE (align, offset, 25) \
MEMCLR_DEFINE_ONE (align, offset, 26) \
MEMCLR_DEFINE_ONE (align, offset, 27) \
MEMCLR_DEFINE_ONE (align, offset, 28) \
MEMCLR_DEFINE_ONE (align, offset, 29) \
MEMCLR_DEFINE_ONE (align, offset, 30) \
MEMCLR_DEFINE_ONE (align, offset, 31) \
MEMCLR_DEFINE_ONE (align, offset, 32) \
MEMCLR_DEFINE_ONE (align, offset, 33) \
MEMCLR_DEFINE_ONE (align, offset, 34) \
MEMCLR_DEFINE_ONE (align, offset, 35) \
MEMCLR_DEFINE_ONE (align, offset, 36) \
MEMCLR_DEFINE_ONE (align, offset, 37) \
MEMCLR_DEFINE_ONE (align, offset, 38) \
MEMCLR_DEFINE_ONE (align, offset, 39) \
MEMCLR_DEFINE_ONE (align, offset, 40) \
MEMCLR_DEFINE_ONE (align, offset, 41) \
MEMCLR_DEFINE_ONE (align, offset, 42) \
MEMCLR_DEFINE_ONE (align, offset, 43) \
MEMCLR_DEFINE_ONE (align, offset, 44) \
MEMCLR_DEFINE_ONE (align, offset, 45) \
MEMCLR_DEFINE_ONE (align, offset, 46) \
MEMCLR_DEFINE_ONE (align, offset, 47) \
MEMCLR_DEFINE_ONE (align, offset, 48) \
MEMCLR_DEFINE_ONE (align, offset, 49) \
MEMCLR_DEFINE_ONE (align, offset, 50) \
MEMCLR_DEFINE_ONE (align, offset, 51) \
MEMCLR_DEFINE_ONE (align, offset, 52) \
MEMCLR_DEFINE_ONE (align, offset, 53) \
MEMCLR_DEFINE_ONE (align, offset, 54) \
MEMCLR_DEFINE_ONE (align, offset, 55) \
MEMCLR_DEFINE_ONE (align, offset, 56) \
MEMCLR_DEFINE_ONE (align, offset, 57) \
MEMCLR_DEFINE_ONE (align, offset, 58) \
MEMCLR_DEFINE_ONE (align, offset, 59) \
MEMCLR_DEFINE_ONE (align, offset, 60) \
MEMCLR_DEFINE_ONE (align, offset, 61) \
MEMCLR_DEFINE_ONE (align, offset, 62) \
MEMCLR_DEFINE_ONE (align, offset, 63) \
MEMCLR_DEFINE_ONE (align, offset, 64)
#define MEMCLR_DEFINE_ONE_ALIGN(align) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 0) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 1) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 2) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 3) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 4) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 5) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 6) \
MEMCLR_DEFINE_ONE_ALIGN_OFFSET (align, 7)
MEMCLR_DEFINE_ONE_ALIGN (1)
MEMCLR_DEFINE_ONE_ALIGN (2)
MEMCLR_DEFINE_ONE_ALIGN (4)
MEMCLR_DEFINE_ONE_ALIGN (8)
#define MEMCLR_CHECK_ONE(align, offset, count) \
memclr_check_one_ ## align ## offset ## count ();
#define MEMCLR_CHECK_ONE_ALIGN_OFFSET(align, offset) \
do \
{ \
MEMCLR_CHECK_ONE (align, offset, 1); \
MEMCLR_CHECK_ONE (align, offset, 2); \
MEMCLR_CHECK_ONE (align, offset, 3); \
MEMCLR_CHECK_ONE (align, offset, 4); \
MEMCLR_CHECK_ONE (align, offset, 5); \
MEMCLR_CHECK_ONE (align, offset, 6); \
MEMCLR_CHECK_ONE (align, offset, 7); \
MEMCLR_CHECK_ONE (align, offset, 8); \
MEMCLR_CHECK_ONE (align, offset, 9); \
MEMCLR_CHECK_ONE (align, offset, 10); \
MEMCLR_CHECK_ONE (align, offset, 11); \
MEMCLR_CHECK_ONE (align, offset, 12); \
MEMCLR_CHECK_ONE (align, offset, 13); \
MEMCLR_CHECK_ONE (align, offset, 14); \
MEMCLR_CHECK_ONE (align, offset, 15); \
MEMCLR_CHECK_ONE (align, offset, 16); \
MEMCLR_CHECK_ONE (align, offset, 17); \
MEMCLR_CHECK_ONE (align, offset, 18); \
MEMCLR_CHECK_ONE (align, offset, 19); \
MEMCLR_CHECK_ONE (align, offset, 20); \
MEMCLR_CHECK_ONE (align, offset, 21); \
MEMCLR_CHECK_ONE (align, offset, 22); \
MEMCLR_CHECK_ONE (align, offset, 23); \
MEMCLR_CHECK_ONE (align, offset, 24); \
MEMCLR_CHECK_ONE (align, offset, 25); \
MEMCLR_CHECK_ONE (align, offset, 26); \
MEMCLR_CHECK_ONE (align, offset, 27); \
MEMCLR_CHECK_ONE (align, offset, 28); \
MEMCLR_CHECK_ONE (align, offset, 29); \
MEMCLR_CHECK_ONE (align, offset, 30); \
MEMCLR_CHECK_ONE (align, offset, 31); \
MEMCLR_CHECK_ONE (align, offset, 32); \
MEMCLR_CHECK_ONE (align, offset, 33); \
MEMCLR_CHECK_ONE (align, offset, 34); \
MEMCLR_CHECK_ONE (align, offset, 35); \
MEMCLR_CHECK_ONE (align, offset, 36); \
MEMCLR_CHECK_ONE (align, offset, 37); \
MEMCLR_CHECK_ONE (align, offset, 38); \
MEMCLR_CHECK_ONE (align, offset, 39); \
MEMCLR_CHECK_ONE (align, offset, 40); \
MEMCLR_CHECK_ONE (align, offset, 41); \
MEMCLR_CHECK_ONE (align, offset, 42); \
MEMCLR_CHECK_ONE (align, offset, 43); \
MEMCLR_CHECK_ONE (align, offset, 44); \
MEMCLR_CHECK_ONE (align, offset, 45); \
MEMCLR_CHECK_ONE (align, offset, 46); \
MEMCLR_CHECK_ONE (align, offset, 47); \
MEMCLR_CHECK_ONE (align, offset, 48); \
MEMCLR_CHECK_ONE (align, offset, 49); \
MEMCLR_CHECK_ONE (align, offset, 50); \
MEMCLR_CHECK_ONE (align, offset, 51); \
MEMCLR_CHECK_ONE (align, offset, 52); \
MEMCLR_CHECK_ONE (align, offset, 53); \
MEMCLR_CHECK_ONE (align, offset, 54); \
MEMCLR_CHECK_ONE (align, offset, 55); \
MEMCLR_CHECK_ONE (align, offset, 56); \
MEMCLR_CHECK_ONE (align, offset, 57); \
MEMCLR_CHECK_ONE (align, offset, 58); \
MEMCLR_CHECK_ONE (align, offset, 59); \
MEMCLR_CHECK_ONE (align, offset, 60); \
MEMCLR_CHECK_ONE (align, offset, 61); \
MEMCLR_CHECK_ONE (align, offset, 62); \
MEMCLR_CHECK_ONE (align, offset, 63); \
MEMCLR_CHECK_ONE (align, offset, 64); \
} \
while (0);
#define MEMCLR_CHECK_ONE_ALIGN(align) \
do \
{ \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 0); \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 1); \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 2); \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 3); \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 4); \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 5); \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 6); \
MEMCLR_CHECK_ONE_ALIGN_OFFSET (align, 7); \
} \
while (0);
int
main (void)
{
MEMCLR_CHECK_ONE_ALIGN (1);
MEMCLR_CHECK_ONE_ALIGN (2);
MEMCLR_CHECK_ONE_ALIGN (4);
MEMCLR_CHECK_ONE_ALIGN (8);
return 0;
}