Janis Johnson
parent
2511b9c42e
commit
be18831b8d
|
|
@ -0,0 +1,152 @@
|
|||
/* Test that __builtin_prefetch does no harm.
|
||||
|
||||
Prefetch data using a variety of storage classes and address
|
||||
expressions. */
|
||||
|
||||
int glob_int_arr[100];
|
||||
int *glob_ptr_int = glob_int_arr;
|
||||
int glob_int = 4;
|
||||
|
||||
static stat_int_arr[100];
|
||||
static int *stat_ptr_int = stat_int_arr;
|
||||
static int stat_int;
|
||||
|
||||
struct S {
|
||||
int a;
|
||||
short b, c;
|
||||
char d[8];
|
||||
struct S *next;
|
||||
};
|
||||
|
||||
struct S str;
|
||||
struct S *ptr_str = &str;
|
||||
|
||||
/* Prefetch global variables using the address of the variable. */
|
||||
|
||||
void
|
||||
simple_global ()
|
||||
{
|
||||
__builtin_prefetch (glob_int_arr, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_int, 0, 0);
|
||||
__builtin_prefetch (&glob_int, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch file-level static variables using the address of the variable. */
|
||||
|
||||
void
|
||||
simple_file ()
|
||||
{
|
||||
__builtin_prefetch (stat_int_arr, 0, 0);
|
||||
__builtin_prefetch (stat_ptr_int, 0, 0);
|
||||
__builtin_prefetch (&stat_int, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch local static variables using the address of the variable. */
|
||||
|
||||
void
|
||||
simple_static_local ()
|
||||
{
|
||||
static int gx[100];
|
||||
static int *hx = gx;
|
||||
static int ix;
|
||||
__builtin_prefetch (gx, 0, 0);
|
||||
__builtin_prefetch (hx, 0, 0);
|
||||
__builtin_prefetch (&ix, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch local stack variables using the address of the variable. */
|
||||
|
||||
void
|
||||
simple_local ()
|
||||
{
|
||||
int gx[100];
|
||||
int *hx = gx;
|
||||
int ix;
|
||||
__builtin_prefetch (gx, 0, 0);
|
||||
__builtin_prefetch (hx, 0, 0);
|
||||
__builtin_prefetch (&ix, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch arguments using the address of the variable. */
|
||||
|
||||
void
|
||||
simple_arg (int g[100], int *h, int i)
|
||||
{
|
||||
__builtin_prefetch (g, 0, 0);
|
||||
__builtin_prefetch (h, 0, 0);
|
||||
__builtin_prefetch (&i, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch using address expressions involving global variables. */
|
||||
|
||||
void
|
||||
expr_global (void)
|
||||
{
|
||||
__builtin_prefetch (&str, 0, 0);
|
||||
__builtin_prefetch (ptr_str, 0, 0);
|
||||
__builtin_prefetch (&str.b, 0, 0);
|
||||
__builtin_prefetch (&ptr_str->b, 0, 0);
|
||||
__builtin_prefetch (&str.d, 0, 0);
|
||||
__builtin_prefetch (&ptr_str->d, 0, 0);
|
||||
__builtin_prefetch (str.next, 0, 0);
|
||||
__builtin_prefetch (ptr_str->next, 0, 0);
|
||||
__builtin_prefetch (str.next->d, 0, 0);
|
||||
__builtin_prefetch (ptr_str->next->d, 0, 0);
|
||||
|
||||
__builtin_prefetch (&glob_int_arr, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_int, 0, 0);
|
||||
__builtin_prefetch (&glob_int_arr[2], 0, 0);
|
||||
__builtin_prefetch (&glob_ptr_int[3], 0, 0);
|
||||
__builtin_prefetch (glob_int_arr+3, 0, 0);
|
||||
__builtin_prefetch (glob_int_arr+glob_int, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_int+5, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_int+glob_int, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch using address expressions involving local variables. */
|
||||
|
||||
void
|
||||
expr_local (void)
|
||||
{
|
||||
int b[10];
|
||||
int *pb = b;
|
||||
struct S t;
|
||||
struct S *pt = &t;
|
||||
int j = 4;
|
||||
|
||||
__builtin_prefetch (&t, 0, 0);
|
||||
__builtin_prefetch (pt, 0, 0);
|
||||
__builtin_prefetch (&t.b, 0, 0);
|
||||
__builtin_prefetch (&pt->b, 0, 0);
|
||||
__builtin_prefetch (&t.d, 0, 0);
|
||||
__builtin_prefetch (&pt->d, 0, 0);
|
||||
__builtin_prefetch (t.next, 0, 0);
|
||||
__builtin_prefetch (pt->next, 0, 0);
|
||||
__builtin_prefetch (t.next->d, 0, 0);
|
||||
__builtin_prefetch (pt->next->d, 0, 0);
|
||||
|
||||
__builtin_prefetch (&b, 0, 0);
|
||||
__builtin_prefetch (pb, 0, 0);
|
||||
__builtin_prefetch (&b[2], 0, 0);
|
||||
__builtin_prefetch (&pb[3], 0, 0);
|
||||
__builtin_prefetch (b+3, 0, 0);
|
||||
__builtin_prefetch (b+j, 0, 0);
|
||||
__builtin_prefetch (pb+5, 0, 0);
|
||||
__builtin_prefetch (pb+j, 0, 0);
|
||||
}
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
simple_global ();
|
||||
simple_file ();
|
||||
simple_static_local ();
|
||||
simple_local ();
|
||||
simple_arg (glob_int_arr, glob_ptr_int, glob_int);
|
||||
|
||||
str.next = &str;
|
||||
expr_global ();
|
||||
expr_local ();
|
||||
|
||||
exit (0);
|
||||
}
|
||||
|
|
@ -0,0 +1,113 @@
|
|||
/* Test that __builtin_prefetch does no harm.
|
||||
|
||||
Prefetch data using a variety of storage classes and address
|
||||
expressions with volatile variables and pointers. */
|
||||
|
||||
int glob_int_arr[100];
|
||||
int glob_int = 4;
|
||||
volatile int glob_vol_int_arr[100];
|
||||
int * volatile glob_vol_ptr_int = glob_int_arr;
|
||||
volatile int *glob_ptr_vol_int = glob_vol_int_arr;
|
||||
volatile int * volatile glob_vol_ptr_vol_int = glob_vol_int_arr;
|
||||
volatile int glob_vol_int;
|
||||
|
||||
static stat_int_arr[100];
|
||||
static volatile int stat_vol_int_arr[100];
|
||||
static int * volatile stat_vol_ptr_int = stat_int_arr;
|
||||
static volatile int *stat_ptr_vol_int = stat_vol_int_arr;
|
||||
static volatile int * volatile stat_vol_ptr_vol_int = stat_vol_int_arr;
|
||||
static volatile int stat_vol_int;
|
||||
|
||||
struct S {
|
||||
int a;
|
||||
short b, c;
|
||||
char d[8];
|
||||
struct S *next;
|
||||
};
|
||||
|
||||
struct S str;
|
||||
volatile struct S vol_str;
|
||||
struct S * volatile vol_ptr_str = &str;
|
||||
volatile struct S *ptr_vol_str = &vol_str;
|
||||
volatile struct S * volatile vol_ptr_vol_str = &vol_str;
|
||||
|
||||
/* Prefetch volatile global variables using the address of the variable. */
|
||||
|
||||
void
|
||||
simple_vol_global ()
|
||||
{
|
||||
__builtin_prefetch (glob_vol_int_arr, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_int, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_vol_int, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_vol_int, 0, 0);
|
||||
__builtin_prefetch (&glob_vol_int, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch volatile static variables using the address of the variable. */
|
||||
|
||||
void
|
||||
simple_vol_file ()
|
||||
{
|
||||
__builtin_prefetch (stat_vol_int_arr, 0, 0);
|
||||
__builtin_prefetch (stat_vol_ptr_int, 0, 0);
|
||||
__builtin_prefetch (stat_ptr_vol_int, 0, 0);
|
||||
__builtin_prefetch (stat_vol_ptr_vol_int, 0, 0);
|
||||
__builtin_prefetch (&stat_vol_int, 0, 0);
|
||||
}
|
||||
|
||||
/* Prefetch using address expressions involving volatile global variables. */
|
||||
|
||||
void
|
||||
expr_vol_global (void)
|
||||
{
|
||||
__builtin_prefetch (&vol_str, 0, 0);
|
||||
__builtin_prefetch (ptr_vol_str, 0, 0);
|
||||
__builtin_prefetch (vol_ptr_str, 0, 0);
|
||||
__builtin_prefetch (vol_ptr_vol_str, 0, 0);
|
||||
__builtin_prefetch (&vol_str.b, 0, 0);
|
||||
__builtin_prefetch (&ptr_vol_str->b, 0, 0);
|
||||
__builtin_prefetch (&vol_ptr_str->b, 0, 0);
|
||||
__builtin_prefetch (&vol_ptr_vol_str->b, 0, 0);
|
||||
__builtin_prefetch (&vol_str.d, 0, 0);
|
||||
__builtin_prefetch (&vol_ptr_str->d, 0, 0);
|
||||
__builtin_prefetch (&ptr_vol_str->d, 0, 0);
|
||||
__builtin_prefetch (&vol_ptr_vol_str->d, 0, 0);
|
||||
__builtin_prefetch (vol_str.next, 0, 0);
|
||||
__builtin_prefetch (vol_ptr_str->next, 0, 0);
|
||||
__builtin_prefetch (ptr_vol_str->next, 0, 0);
|
||||
__builtin_prefetch (vol_ptr_vol_str->next, 0, 0);
|
||||
__builtin_prefetch (vol_str.next->d, 0, 0);
|
||||
__builtin_prefetch (vol_ptr_str->next->d, 0, 0);
|
||||
__builtin_prefetch (ptr_vol_str->next->d, 0, 0);
|
||||
__builtin_prefetch (vol_ptr_vol_str->next->d, 0, 0);
|
||||
|
||||
__builtin_prefetch (&glob_vol_int_arr, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_int, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_vol_int, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_vol_int, 0, 0);
|
||||
__builtin_prefetch (&glob_vol_int_arr[2], 0, 0);
|
||||
__builtin_prefetch (&glob_vol_ptr_int[3], 0, 0);
|
||||
__builtin_prefetch (&glob_ptr_vol_int[3], 0, 0);
|
||||
__builtin_prefetch (&glob_vol_ptr_vol_int[3], 0, 0);
|
||||
__builtin_prefetch (glob_vol_int_arr+3, 0, 0);
|
||||
__builtin_prefetch (glob_vol_int_arr+glob_vol_int, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_int+5, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_vol_int+5, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_vol_int+5, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_int+glob_vol_int, 0, 0);
|
||||
__builtin_prefetch (glob_ptr_vol_int+glob_vol_int, 0, 0);
|
||||
__builtin_prefetch (glob_vol_ptr_vol_int+glob_vol_int, 0, 0);
|
||||
}
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
simple_vol_global ();
|
||||
simple_vol_file ();
|
||||
|
||||
str.next = &str;
|
||||
vol_str.next = &str;
|
||||
expr_vol_global ();
|
||||
|
||||
exit (0);
|
||||
}
|
||||
|
|
@ -0,0 +1,271 @@
|
|||
/* Test that __builtin_prefetch does no harm.
|
||||
|
||||
Check that the expression containing the address to prefetch is
|
||||
evaluated if it has side effects, even if the target does not support
|
||||
data prefetch. Check changes to pointers and to array indices that are
|
||||
either global variables or arguments. */
|
||||
|
||||
#define ARRSIZE 100
|
||||
|
||||
int arr[ARRSIZE];
|
||||
int *ptr = &arr[20];
|
||||
int arrindex = 4;
|
||||
|
||||
/* Check that assignment within a prefetch argument is evaluated. */
|
||||
|
||||
int
|
||||
assign_arg_ptr (int *p)
|
||||
{
|
||||
int *q;
|
||||
__builtin_prefetch ((q = p), 0, 0);
|
||||
return q == p;
|
||||
}
|
||||
|
||||
int
|
||||
assign_glob_ptr (void)
|
||||
{
|
||||
int *q;
|
||||
__builtin_prefetch ((q = ptr), 0, 0);
|
||||
return q == ptr;
|
||||
}
|
||||
|
||||
int
|
||||
assign_arg_idx (int *p, int i)
|
||||
{
|
||||
int j;
|
||||
__builtin_prefetch (&p[j = i], 0, 0);
|
||||
return j == i;
|
||||
}
|
||||
|
||||
int
|
||||
assign_glob_idx (void)
|
||||
{
|
||||
int j;
|
||||
__builtin_prefetch (&ptr[j = arrindex], 0, 0);
|
||||
return j == arrindex;
|
||||
}
|
||||
|
||||
/* Check that pre/post increment/decrement within a prefetch argument are
|
||||
evaluated. */
|
||||
|
||||
int
|
||||
preinc_arg_ptr (int *p)
|
||||
{
|
||||
int *q;
|
||||
q = p + 1;
|
||||
__builtin_prefetch (++p, 0, 0);
|
||||
return p == q;
|
||||
}
|
||||
|
||||
int
|
||||
preinc_glob_ptr (void)
|
||||
{
|
||||
int *q;
|
||||
q = ptr + 1;
|
||||
__builtin_prefetch (++ptr, 0, 0);
|
||||
return ptr == q;
|
||||
}
|
||||
|
||||
int
|
||||
postinc_arg_ptr (int *p)
|
||||
{
|
||||
int *q;
|
||||
q = p + 1;
|
||||
__builtin_prefetch (p++, 0, 0);
|
||||
return p == q;
|
||||
}
|
||||
|
||||
int
|
||||
postinc_glob_ptr (void)
|
||||
{
|
||||
int *q;
|
||||
q = ptr + 1;
|
||||
__builtin_prefetch (ptr++, 0, 0);
|
||||
return ptr == q;
|
||||
}
|
||||
|
||||
int
|
||||
predec_arg_ptr (int *p)
|
||||
{
|
||||
int *q;
|
||||
q = p - 1;
|
||||
__builtin_prefetch (--p, 0, 0);
|
||||
return p == q;
|
||||
}
|
||||
|
||||
int
|
||||
predec_glob_ptr (void)
|
||||
{
|
||||
int *q;
|
||||
q = ptr - 1;
|
||||
__builtin_prefetch (--ptr, 0, 0);
|
||||
return ptr == q;
|
||||
}
|
||||
|
||||
int
|
||||
postdec_arg_ptr (int *p)
|
||||
{
|
||||
int *q;
|
||||
q = p - 1;
|
||||
__builtin_prefetch (p--, 0, 0);
|
||||
return p == q;
|
||||
}
|
||||
|
||||
int
|
||||
postdec_glob_ptr (void)
|
||||
{
|
||||
int *q;
|
||||
q = ptr - 1;
|
||||
__builtin_prefetch (ptr--, 0, 0);
|
||||
return ptr == q;
|
||||
}
|
||||
|
||||
int
|
||||
preinc_arg_idx (int *p, int i)
|
||||
{
|
||||
int j = i + 1;
|
||||
__builtin_prefetch (&p[++i], 0, 0);
|
||||
return i == j;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
preinc_glob_idx (void)
|
||||
{
|
||||
int j = arrindex + 1;
|
||||
__builtin_prefetch (&ptr[++arrindex], 0, 0);
|
||||
return arrindex == j;
|
||||
}
|
||||
|
||||
int
|
||||
postinc_arg_idx (int *p, int i)
|
||||
{
|
||||
int j = i + 1;
|
||||
__builtin_prefetch (&p[i++], 0, 0);
|
||||
return i == j;
|
||||
}
|
||||
|
||||
int
|
||||
postinc_glob_idx (void)
|
||||
{
|
||||
int j = arrindex + 1;
|
||||
__builtin_prefetch (&ptr[arrindex++], 0, 0);
|
||||
return arrindex == j;
|
||||
}
|
||||
|
||||
int
|
||||
predec_arg_idx (int *p, int i)
|
||||
{
|
||||
int j = i - 1;
|
||||
__builtin_prefetch (&p[--i], 0, 0);
|
||||
return i == j;
|
||||
}
|
||||
|
||||
int
|
||||
predec_glob_idx (void)
|
||||
{
|
||||
int j = arrindex - 1;
|
||||
__builtin_prefetch (&ptr[--arrindex], 0, 0);
|
||||
return arrindex == j;
|
||||
}
|
||||
|
||||
int
|
||||
postdec_arg_idx (int *p, int i)
|
||||
{
|
||||
int j = i - 1;
|
||||
__builtin_prefetch (&p[i--], 0, 0);
|
||||
return i == j;
|
||||
}
|
||||
|
||||
int
|
||||
postdec_glob_idx (void)
|
||||
{
|
||||
int j = arrindex - 1;
|
||||
__builtin_prefetch (&ptr[arrindex--], 0, 0);
|
||||
return arrindex == j;
|
||||
}
|
||||
|
||||
/* Check that function calls within the first prefetch argument are
|
||||
evaluated. */
|
||||
|
||||
int getptrcnt = 0;
|
||||
|
||||
int *
|
||||
getptr (int *p)
|
||||
{
|
||||
getptrcnt++;
|
||||
return p + 1;
|
||||
}
|
||||
|
||||
int
|
||||
funccall_arg_ptr (int *p)
|
||||
{
|
||||
__builtin_prefetch (getptr (p), 0, 0);
|
||||
return getptrcnt == 1;
|
||||
}
|
||||
|
||||
int getintcnt = 0;
|
||||
|
||||
int
|
||||
getint (int i)
|
||||
{
|
||||
getintcnt++;
|
||||
return i + 1;
|
||||
}
|
||||
|
||||
int
|
||||
funccall_arg_idx (int *p, int i)
|
||||
{
|
||||
__builtin_prefetch (&p[getint (i)], 0, 0);
|
||||
return getintcnt == 1;
|
||||
}
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
if (!assign_arg_ptr (ptr))
|
||||
abort ();
|
||||
if (!assign_glob_ptr ())
|
||||
abort ();
|
||||
if (!assign_arg_idx (ptr, 4))
|
||||
abort ();
|
||||
if (!assign_glob_idx ())
|
||||
abort ();
|
||||
if (!preinc_arg_ptr (ptr))
|
||||
abort ();
|
||||
if (!preinc_glob_ptr ())
|
||||
abort ();
|
||||
if (!postinc_arg_ptr (ptr))
|
||||
abort ();
|
||||
if (!postinc_glob_ptr ())
|
||||
abort ();
|
||||
if (!predec_arg_ptr (ptr))
|
||||
abort ();
|
||||
if (!predec_glob_ptr ())
|
||||
abort ();
|
||||
if (!postdec_arg_ptr (ptr))
|
||||
abort ();
|
||||
if (!postdec_glob_ptr ())
|
||||
abort ();
|
||||
if (!preinc_arg_idx (ptr, 3))
|
||||
abort ();
|
||||
if (!preinc_glob_idx ())
|
||||
abort ();
|
||||
if (!postinc_arg_idx (ptr, 3))
|
||||
abort ();
|
||||
if (!postinc_glob_idx ())
|
||||
abort ();
|
||||
if (!predec_arg_idx (ptr, 3))
|
||||
abort ();
|
||||
if (!predec_glob_idx ())
|
||||
abort ();
|
||||
if (!postdec_arg_idx (ptr, 3))
|
||||
abort ();
|
||||
if (!postdec_glob_idx ())
|
||||
abort ();
|
||||
if (!funccall_arg_ptr (ptr))
|
||||
abort ();
|
||||
if (!funccall_arg_idx (ptr, 3))
|
||||
abort ();
|
||||
exit (0);
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
/* Test that __builtin_prefetch does no harm.
|
||||
|
||||
Use addresses that are unlikely to be word-aligned. Some targets
|
||||
have alignment requirements for prefetch addresses, so make sure the
|
||||
compiler takes care of that. This fails if it aborts, anything else
|
||||
is OK. */
|
||||
|
||||
struct S {
|
||||
short a;
|
||||
short b;
|
||||
char c[8];
|
||||
} s;
|
||||
|
||||
char arr[100];
|
||||
char *ptr = arr;
|
||||
int idx = 3;
|
||||
|
||||
void
|
||||
arg_ptr (char *p)
|
||||
{
|
||||
__builtin_prefetch (p, 0, 0);
|
||||
}
|
||||
|
||||
void
|
||||
arg_idx (char *p, int i)
|
||||
{
|
||||
__builtin_prefetch (&p[i], 0, 0);
|
||||
}
|
||||
|
||||
void
|
||||
glob_ptr (void)
|
||||
{
|
||||
__builtin_prefetch (ptr, 0, 0);
|
||||
}
|
||||
|
||||
void
|
||||
glob_idx (void)
|
||||
{
|
||||
__builtin_prefetch (&ptr[idx], 0, 0);
|
||||
}
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
__builtin_prefetch (&s.b, 0, 0);
|
||||
__builtin_prefetch (&s.c[1], 0, 0);
|
||||
|
||||
arg_ptr (&s.c[1]);
|
||||
arg_ptr (ptr+3);
|
||||
arg_idx (ptr, 3);
|
||||
arg_idx (ptr+1, 2);
|
||||
idx = 3;
|
||||
glob_ptr ();
|
||||
glob_idx ();
|
||||
ptr++;
|
||||
idx = 2;
|
||||
glob_ptr ();
|
||||
glob_idx ();
|
||||
exit (0);
|
||||
}
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/* Test that __builtin_prefetch does no harm.
|
||||
|
||||
Data prefetch should not fault if used with an invalid address. */
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#define ARRSIZE 65
|
||||
int *bad_addr[ARRSIZE];
|
||||
int arr_used;
|
||||
|
||||
/* Fill bad_addr with a range of values in the hopes that on any target
|
||||
some will be invalid addresses. */
|
||||
void
|
||||
init_addrs (void)
|
||||
{
|
||||
int i;
|
||||
int bits_per_ptr = sizeof (void *) * 8;
|
||||
for (i = 0; i < bits_per_ptr; i++)
|
||||
bad_addr[i] = (void *)(1UL << i);
|
||||
arr_used = bits_per_ptr + 1; /* The last element used is zero. */
|
||||
}
|
||||
|
||||
void
|
||||
prefetch_for_read (void)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < ARRSIZE; i++)
|
||||
__builtin_prefetch (bad_addr[i], 0, 0);
|
||||
}
|
||||
|
||||
void
|
||||
prefetch_for_write (void)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < ARRSIZE; i++)
|
||||
__builtin_prefetch (bad_addr[i], 1, 0);
|
||||
}
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
init_addrs ();
|
||||
prefetch_for_read ();
|
||||
prefetch_for_write ();
|
||||
exit (0);
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
/* Test that __builtin_prefetch does no harm.
|
||||
|
||||
Prefetch using some invalid rw and locality values. These must be
|
||||
compile-time constants. */
|
||||
|
||||
/* { dg-do run } */
|
||||
|
||||
enum locality { none, low, moderate, high, bogus };
|
||||
enum rw { read, write };
|
||||
|
||||
int arr[10];
|
||||
|
||||
void
|
||||
good (int *p)
|
||||
{
|
||||
__builtin_prefetch (p, 0, 0);
|
||||
__builtin_prefetch (p, 0, 1);
|
||||
__builtin_prefetch (p, 0, 2);
|
||||
__builtin_prefetch (p, 0, 3);
|
||||
__builtin_prefetch (p, 1, 0);
|
||||
__builtin_prefetch (p, 1, 1);
|
||||
__builtin_prefetch (p, 1, 2);
|
||||
__builtin_prefetch (p, 1, 3);
|
||||
}
|
||||
|
||||
void
|
||||
bad (int *p)
|
||||
{
|
||||
__builtin_prefetch (p, -1, 0); /* { dg-warning "invalid second arg to __builtin_prefetch; using zero" } */
|
||||
__builtin_prefetch (p, 2, 0); /* { dg-warning "invalid second arg to __builtin_prefetch; using zero" } */
|
||||
__builtin_prefetch (p, bogus, 0); /* { dg-warning "invalid second arg to __builtin_prefetch; using zero" } */
|
||||
__builtin_prefetch (p, 0, -1); /* { dg-warning "invalid third arg to __builtin_prefetch; using zero" } */
|
||||
__builtin_prefetch (p, 0, 4); /* { dg-warning "invalid third arg to __builtin_prefetch; using zero" } */
|
||||
__builtin_prefetch (p, 0, bogus); /* { dg-warning "invalid third arg to __builtin_prefetch; using zero" } */
|
||||
}
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
good (arr);
|
||||
bad (arr);
|
||||
exit (0);
|
||||
}
|
||||
Loading…
Reference in New Issue