--- /dev/null
+/* 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);
+}
--- /dev/null
+/* 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);
+}
--- /dev/null
+/* 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);
+}
--- /dev/null
+/* 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);
+}
--- /dev/null
+/* 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);
+}
--- /dev/null
+/* 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);
+}
OSDN Git Service
