@@ -71,7 +71,8 @@
#define bit_AVX2 (1 << 5)
#define bit_BMI2 (1 << 8)
#define bit_RTM (1 << 11)
-#define bit_AVX512F (1 << 16)
+#define bit_MPX (1 << 14)
+#define bit_AVX512F (1 << 16)
#define bit_RDSEED (1 << 18)
#define bit_ADX (1 << 19)
#define bit_AVX512PF (1 << 26)
new file mode 100644
@@ -0,0 +1,23 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *buf = (int *)alloca (100 * sizeof(int));
+
+ rd (buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *buf = (int *)alloca (100 * sizeof(int));
+
+ rd (buf, 0);
+ rd (buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,23 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *buf = (int *)alloca (100 * sizeof(int));
+
+ rd (buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int foo (int i, int j)
+{
+ return rd(&i, j);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (1, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int foo (int i, int j)
+{
+ return rd(&i, j);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (1, 0);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int foo (int i, int j)
+{
+ return rd(&i, j);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (1, 1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s {
+ int a;
+ int b : 10;
+ int c : 1;
+ int e : 10;
+} s;
+
+#define HH (unsigned char)1
+
+int foo (struct s *p)
+{
+ int val = p->b;
+ printf ("%d\n", val);
+ return val == HH;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s buf[100];
+
+ foo (buf - 1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s {
+ int a;
+ int b : 10;
+ int c : 1;
+ int e : 10;
+} s;
+
+#define HH (unsigned char)1
+
+int foo (struct s *p)
+{
+ int val = p->b;
+ printf ("%d\n", val);
+ return val == HH;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s buf[100];
+
+ foo (buf);
+ foo (buf + 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s {
+ int a;
+ int b : 10;
+ int c : 1;
+ int e : 10;
+} s;
+
+#define HH (unsigned char)1
+
+int foo (struct s *p)
+{
+ int val = p->b;
+ printf ("%d\n", val);
+ return val == HH;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s buf[100];
+
+ foo (buf + 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_bounds (buf - 1, sizeof (int));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_bounds (buf, sizeof (int) * 100);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_bounds (buf + 100, sizeof (int));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,14 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_bounds (buf - 1, sizeof (int));
+ __bnd_chk_ptr_bounds (buf + 100, sizeof (int));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_lbounds (buf - 1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_lbounds (buf);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_lbounds (buf - 1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_ubounds (buf + 99);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_ubounds (buf + 100);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ __bnd_chk_ptr_ubounds (buf + 100);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 10 == __bnd_copy_ptr_bounds (buf + 10, buf));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,17 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ int *p1 = __bnd_copy_ptr_bounds (buf, p);
+ p1[9] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ int *p1 = __bnd_copy_ptr_bounds (buf, p);
+ p1[10] = argc;
+ p1[19] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,17 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ int *p1 = __bnd_copy_ptr_bounds (buf, p);
+ p1[20] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 10 == __bnd_copy_ptr_bounds (buf + 10, buf));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+char buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf == __bnd_get_ptr_lbound (buf));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+char buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert ((void *)0 == __bnd_get_ptr_lbound (buf));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+char buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 99 == __bnd_get_ptr_ubound (buf));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+char buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert ((void *)-1 == __bnd_get_ptr_ubound (buf));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 10 == __bnd_init_ptr_bounds (buf + 10));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p = __bnd_init_ptr_bounds (p);
+ p[-1] = argc;
+ p[10] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 10 == __bnd_init_ptr_bounds (buf + 10));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 10 == __bnd_narrow_ptr_bounds (buf + 10, buf, 4));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_narrow_ptr_bounds (buf - 10, buf, sizeof (int) * 20);
+ p[9] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_narrow_ptr_bounds (buf - 10, buf, sizeof (int) * 20);
+ p[10] = argc;
+ p[19] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_narrow_ptr_bounds (buf - 10, buf, sizeof (int) * 20);
+ p[20] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_narrow_ptr_bounds (buf + 10, buf, sizeof (int) * 100);
+ p[-1] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_narrow_ptr_bounds (buf + 10, buf, sizeof (int) * 100);
+ p[0] = argc;
+ p[89] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_narrow_ptr_bounds (buf + 10, buf, sizeof (int) * 100);
+ p[90] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf - 10 == __bnd_narrow_ptr_bounds (buf - 10, buf, 4));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_null_ptr_bounds (buf + 10);
+ p[0] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 10 == __bnd_set_ptr_bounds (buf + 10, 4));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p[-1] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p[0] = argc;
+ p[9] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p[10] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,13 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ assert (buf + 10 == __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,19 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p;
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p1 = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p = buf;
+ __bnd_store_ptr_bounds ((void **)&p, p1 - 10);
+ p[9] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,18 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p;
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p1 = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p = buf;
+ __bnd_store_ptr_bounds ((void **)&p, p1 - 10);
+ p[10] = argc;
+ p[19] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,19 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p;
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p1 = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p = buf;
+ __bnd_store_ptr_bounds ((void **)&p, p1 - 10);
+ p[20] = argc;
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-fno-check-pointer-bounds" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p;
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p1 = __bnd_set_ptr_bounds (buf + 10, sizeof (int) * 10);
+ p = buf;
+ __bnd_store_ptr_bounds ((void **)&p, p1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+__attribute__((fastcall)) int rd (int *p1, int *p2, int i)
+{
+ int res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+__attribute__((fastcall)) int rd (int *p1, int *p2, int i)
+{
+ int res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, buf, 0);
+ rd (buf1, buf, 9);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+__attribute__((fastcall)) int rd (int *p1, int *p2, int i)
+{
+ int res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, buf, 10);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+__attribute__((fastcall)) int rd (int *p1, int *p2, int i)
+{
+ int res = p2[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf, buf1, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+__attribute__((fastcall)) int rd (int *p1, int *p2, int i)
+{
+ int res = p2[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf, buf1, 0);
+ rd (buf, buf1, 9);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+__attribute__((fastcall)) int rd (int *p1, int *p2, int i)
+{
+ int res = p2[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf, buf1, 10);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *i, int k)
+{
+ printf ("%d\n", i[k]);
+ return i[k];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo(&s.a, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *i, int k)
+{
+ printf ("%d\n", i[k]);
+ return i[k];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo(&s.a, 0);
+ foo(&s.a, 101);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *i, int k)
+{
+ printf ("%d\n", i[k]);
+ return i[k];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo(&s.a, 102);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int arr[100];
+} S;
+
+struct S sa[10];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (&sa[argc].arr[0], -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#include "mpx-check.h"
+
+struct S {
+ int arr[100];
+} S;
+
+struct S sa[10];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (&sa[argc].arr[0], 0);
+ rd (&sa[argc].arr[0], 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int arr[100];
+} S;
+
+struct S sa[10];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (&sa[argc].arr[0], 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-first-field-has-own-bounds" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *i, int k)
+{
+ printf ("%d\n", i[k]);
+ return i[k];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo(&s.a, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-first-field-has-own-bounds" } */
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *i, int k)
+{
+ printf ("%d\n", i[k]);
+ return i[k];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo(&s.a, 0);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-first-field-has-own-bounds" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *i, int k)
+{
+ printf ("%d\n", i[k]);
+ return i[k];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo(&s.a, 1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S s;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s.b[0], -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S s;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s.b[0], 0);
+ foo (&s.b[0], 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S s;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s.b[0], 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,34 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s1.a[0].a, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s1.a[9].c, 0);
+ foo (&s1.a[0].a, 0);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,34 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s1.a[9].c, 1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,34 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s1.b.b[0], -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s1.b.b[0], 0);
+ foo (&s1.b.b[0], 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,34 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&s1.b.b[0], 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+struct S1 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[0].a), -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+struct S1 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[0].a), 0);
+ foo (&(s2->a[9].a), 101);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+struct S1 {
+ int x;
+ struct S a[10];
+ struct S b;
+} S1;
+
+int foo (int *p, int i)
+{
+ printf ("%d\n", p[i]);
+ return p[i];
+}
+
+struct S1 s1;
+struct S1 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[9].a), 102);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,41 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[-1].a), 0);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S {
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[0].a), 0);
+ foo (&(s2->a[9].c), 0);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,41 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[10].a), 0);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,42 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s1.a[argc].b[-1].a[0]), 9);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,43 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#include "mpx-check.h"
+
+struct S {
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s1.a[argc].b[0].a[0]), 0);
+ foo (&(s1.a[argc].b[0].a[0]), 9);
+ foo (&(s1.a[argc].b[9].a[0]), 0);
+ foo (&(s1.a[argc].b[9].a[0]), 9);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,42 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s1.a[argc].b[10].a[0]), 9);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,43 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int first;
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[argc].b[5].a[0]), -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,42 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#include "mpx-check.h"
+
+struct S {
+ int first;
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[argc].b[5].a[0]), 0);
+ foo (&(s2->a[argc].b[5].a[0]), 9);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,43 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-fchkp-narrow-to-innermost-array" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int first;
+ int a[10];
+ int b;
+} S;
+
+struct S1 {
+ int a;
+ struct S b[10];
+ int c;
+} S1;
+
+struct S2 {
+ int x;
+ struct S1 a[10];
+ struct S1 b;
+} S2;
+
+int foo (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+struct S2 s1;
+struct S2 *s2 = &s1;
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (&(s2->a[argc].b[5].a[0]), 10);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,12 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int mpx_test (int argc, const char **argv)
+{
+ void **fa = (void **)__builtin_frame_address (0);
+ printf ("%p\n", *fa);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ register int *frame __asm__("rsp");
+ rd (frame, 1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p1, int *p2, int i)
+{
+ int res;
+
+ if (p1 < p2)
+ p1 = p2;
+
+ res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 1, 40);
+ rd (buf, p, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int rd (int *p1, int *p2, int i)
+{
+ int res;
+
+ if (p1 < p2)
+ p1 = p2;
+
+ res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 1, 40);
+ rd (buf, p, 0);
+ rd (buf, p, 9);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p1, int *p2, int i)
+{
+ int res;
+
+ if (p1 < p2)
+ p1 = p2;
+
+ res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 1, 40);
+ rd (buf, p, 10);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p1, int *p2, int i)
+{
+ int res;
+
+ if (p1 > p2)
+ p1 = p2;
+
+ res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 1, 40);
+ rd (buf, p, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int rd (int *p1, int *p2, int i)
+{
+ int res;
+
+ if (p1 > p2)
+ p1 = p2;
+
+ res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 1, 40);
+ rd (buf, p, 0);
+ rd (buf, p, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int rd (int *p1, int *p2, int i)
+{
+ int res;
+
+ if (p1 > p2)
+ p1 = p2;
+
+ res = p1[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 1, 40);
+ rd (buf, p, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+void *p;
+int mpx_test (int argc, const char **argv)
+{
+ p = &&label;
+
+ label:
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+__attribute__((bnd_legacy))
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p = __bnd_set_ptr_bounds (buf + 1, 10);
+
+ rd (p, -1);
+ rd (p, 10);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+#ifndef __MPX__
+#error -mmpx is required
+#endif
+
+#ifndef __CHKP__
+#error -fcheck-pointer-bounds is required
+#endif
+
+int mpx_test (int argc, const char **argv)
+{
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "cpuid.h"
+
+static int
+__attribute__ ((noinline))
+mpx_test (int, const char **);
+
+#ifdef XFAIL
+#define NORUNRES 1
+#else
+#define NORUNRES 0
+#endif
+
+#define DEBUG
+
+int
+main (int argc, const char **argv)
+{
+ unsigned int eax, ebx, ecx, edx;
+
+ if (__get_cpuid_max (0, NULL) < 7)
+ return 0;
+
+ __cpuid_count (7, 0, eax, ebx, ecx, edx);
+
+ /* Run MPX test only if host has MPX support. */
+ if (ebx & bit_MPX)
+ {
+ mpx_test (argc, argv);
+#ifdef DEBUG
+ printf ("PASSED\n");
+#endif
+ }
+ else
+ {
+#ifdef DEBUG
+ printf ("SKIPPED\n");
+#endif
+ return NORUNRES;
+ }
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,34 @@
+# Copyright (C) 2012-2013 Free Software Foundation, Inc.
+#
+# This file is part of GCC.
+#
+# GCC is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# GCC is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3. If not see
+# <http://www.gnu.org/licenses/>.
+
+# Load support procs.
+load_lib gcc-dg.exp
+load_lib mpx-dg.exp
+
+if ![check_effective_target_mpx] {
+ return
+}
+
+# Initialize `dg'.
+dg-init
+
+# Run all tests.
+gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.c*]] ""
+
+# All done.
+dg-finish
new file mode 100644
@@ -0,0 +1,21 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int mpx_test (int argc, const char **argv)
+{
+ int a[100];
+
+ void rd (int i)
+ {
+ printf ("%d\n", a[i]);
+ }
+
+ rd (-1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,20 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int mpx_test (int argc, const char **argv)
+{
+ int a[100];
+
+ void rd (int i)
+ {
+ printf ("%d\n", a[i]);
+ }
+
+ rd (0);
+ rd (99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,21 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int mpx_test (int argc, const char **argv)
+{
+ int a[100];
+
+ void rd (int i)
+ {
+ printf ("%d\n", a[i]);
+ }
+
+ rd (100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf, 0);
+ rd (buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int t1, int t2, int t3, int t4, int t5, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (0, 0, 0, 0, 0, buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int t1, int t2, int t3, int t4, int t5, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (0, 0, 0, 0, 0, buf, 0);
+ rd (0, 0, 0, 0, 0, buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int t1, int t2, int t3, int t4, int t5, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (0, 0, 0, 0, 0, buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int t1, int t2, int t3, int t4, int t5, int t6, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (0, 0, 0, 0, 0, 0, buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int t1, int t2, int t3, int t4, int t5, int t6, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (0, 0, 0, 0, 0, 0, buf, 0);
+ rd (0, 0, 0, 0, 0, 0, buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int t1, int t2, int t3, int t4, int t5, int t6, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (0, 0, 0, 0, 0, 0, buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *t1, int *t2, int *t3, int *t4, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf1, buf1, buf1, buf1, buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *t1, int *t2, int *t3, int *t4, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf1, buf1, buf1, buf1, buf, 0);
+ rd (buf1, buf1, buf1, buf1, buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *t1, int *t2, int *t3, int *t4, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf1, buf1, buf1, buf1, buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *t1, int *t2, int *t3, int *t4, int *t5, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf1, buf1, buf1, buf1, buf1, buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *t1, int *t2, int *t3, int *t4, int *t5, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf1, buf1, buf1, buf1, buf1, buf, 0);
+ rd (buf1, buf1, buf1, buf1, buf1, buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *t1, int *t2, int *t3, int *t4, int *t5, int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf1, buf1, buf1, buf1, buf1, buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int *buf1[100];
+int buf2[100];
+
+void wr (int i)
+{
+ buf1[i] = buf2;
+}
+
+int rd(int i, int j)
+{
+ int res = buf1[i][j];
+ printf("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ wr(10);
+ rd(10, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int *buf1[100];
+int buf2[100];
+
+void wr (int i)
+{
+ buf1[i] = buf2;
+}
+
+int rd(int i, int j)
+{
+ int res = buf1[i][j];
+ printf("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ wr(10);
+ rd(10, 0);
+ rd(10, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int *buf1[100];
+int buf2[100];
+
+void wr (int i)
+{
+ buf1[i] = buf2;
+}
+
+int rd(int i, int j)
+{
+ int res = buf1[i][j];
+ printf("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ wr(10);
+ rd(10, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int __attribute((nothrow))
+rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+void set_p (int *&ref)
+{
+ ref = buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ set_p (p);
+ rd (p, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int __attribute((nothrow))
+rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+void set_p (int *&ref)
+{
+ ref = buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ set_p (p);
+ rd (p, 0);
+ rd (p, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int __attribute((nothrow))
+rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+void set_p (int *&ref)
+{
+ ref = buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ set_p (p);
+ rd (p, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int __attribute((nothrow))
+rd (int *&p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+void set_p (int *&ref)
+{
+ ref = buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ set_p (p);
+ rd (p, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int __attribute((nothrow))
+rd (int *&p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+void set_p (int *&ref)
+{
+ ref = buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ set_p (p);
+ rd (p, 0);
+ rd (p, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int __attribute((nothrow))
+rd (int *&p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+void set_p (int *&ref)
+{
+ ref = buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ set_p (p);
+ rd (p, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int (&p)[100], int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int (&p)[100], int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf, 0);
+ rd (buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int (&p)[100], int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int (&p)[100], int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int (&get_buf ()) [100]
+{
+ return buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (get_buf (), -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int (&p)[100], int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int (&get_buf ()) [100]
+{
+ return buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (get_buf (), 0);
+ rd (get_buf (), 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int rd (int (&p)[100], int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int (&get_buf ()) [100]
+{
+ return buf;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int *p;
+
+ rd (get_buf (), 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,42 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int *_buf1[100];
+int _buf2[100];
+
+int **get_buf1 ()
+{
+ return _buf1;
+}
+
+int *get_buf2 ()
+{
+ return _buf2;
+}
+
+void wr (int i, int **buf1, int *buf2)
+{
+ buf1[i] = buf2;
+}
+
+int rd (int i, int j, int **buf)
+{
+ int res = buf[i][j];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int **buf1 = get_buf1 ();
+ int *buf2 = get_buf2 ();
+ wr(10, buf1, buf2);
+ rd(10, -1, buf1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,41 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int *_buf1[100];
+int _buf2[100];
+
+int **get_buf1 ()
+{
+ return _buf1;
+}
+
+int *get_buf2 ()
+{
+ return _buf2;
+}
+
+void wr (int i, int **buf1, int *buf2)
+{
+ buf1[i] = buf2;
+}
+
+int rd (int i, int j, int **buf)
+{
+ int res = buf[i][j];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int **buf1 = get_buf1 ();
+ int *buf2 = get_buf2 ();
+ wr(10, buf1, buf2);
+ rd(10, 0, buf1);
+ rd(10, 99, buf1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,42 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int *_buf1[100];
+int _buf2[100];
+
+int **get_buf1 ()
+{
+ return _buf1;
+}
+
+int *get_buf2 ()
+{
+ return _buf2;
+}
+
+void wr (int i, int **buf1, int *buf2)
+{
+ buf1[i] = buf2;
+}
+
+int rd (int i, int j, int **buf)
+{
+ int res = buf[i][j];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ int **buf1 = get_buf1 ();
+ int *buf2 = get_buf2 ();
+ wr(10, buf1, buf2);
+ rd(10, 100, buf1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,40 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int *p1;
+} s1;
+
+int buf[100];
+int buf1[10];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ s.p1 = buf1;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int *p1;
+} s1;
+
+int buf[100];
+int buf1[10];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ s.p1 = buf1;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,40 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int *p1;
+} s1;
+
+int buf[100];
+int buf1[10];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ s.p1 = buf1;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,40 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p1;
+ int *p;
+} s1;
+
+int buf[100];
+int buf1[10];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ s.p1 = buf1;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p1;
+ int *p;
+} s1;
+
+int buf[100];
+int buf1[10];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ s.p1 = buf1;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,40 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p1;
+ int *p;
+} s1;
+
+int buf[100];
+int buf1[10];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ s.p1 = buf1;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,41 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+ int i3;
+ int i4;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+ int i3;
+ int i4;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,41 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+ int i3;
+ int i4;
+} s1;
+
+int buf[100];
+
+struct s1 __attribute__((noinline)) get ()
+{
+ struct s1 s;
+ s.p = buf;
+ return s;
+}
+
+int __attribute__((noinline)) rd (struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = get ();
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,18 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+/* { dg-additional-options "-lm" } */
+
+
+#include "mpx-check.h"
+#include "math.h"
+
+int mpx_test (int argc, const char **argv)
+{
+ double d1, d2;
+ d1 = sin(argc);
+ d2 = cos(argc);
+
+ printf ("%f %f\n", d1, d2);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ printf("%d\n", buf[-1]);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,14 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ printf("%d\n", buf[0]);
+ printf("%d\n", buf[99]);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,15 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ printf("%d\n", buf[100]);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,17 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p = buf;
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", p[-1]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p = buf;
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", p[0]);
+ printf ("%d\n", p[99]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,17 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p = buf;
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", p[100]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,23 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s {
+ int a;
+ int *p;
+} s;
+
+int buf[100];
+
+struct s s1 = {0, buf};
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", s1.p[-1]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s {
+ int a;
+ int *p;
+} s;
+
+int buf[100];
+
+struct s s1 = {0, buf};
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", s1.p[0]);
+ printf ("%d\n", s1.p[99]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,23 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s {
+ int a;
+ int *p;
+} s;
+
+int buf[100];
+
+struct s s1 = {0, buf};
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", s1.p[100]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p = buf;
+
+int foo (int i)
+{
+ static int **pp = &p;
+
+ return (*pp)[i];
+}
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", foo (-1));
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,23 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p = buf;
+
+int foo (int i)
+{
+ static int **pp = &p;
+
+ return (*pp)[i];
+}
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", foo (0));
+ printf ("%d\n", foo (99));
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p = buf;
+
+int foo (int i)
+{
+ static int **pp = &p;
+
+ return (*pp)[i];
+}
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", foo (100));
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,17 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p[1] = { buf };
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", p[0][-1]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,16 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p[1] = { buf };
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", p[0][0]);
+ printf ("%d\n", p[0][99]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,17 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf[100];
+int *p[1] = { buf };
+
+int mpx_test (int argc, const char *argv[])
+{
+ printf ("%d\n", p[0][100]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+int mpx_test (int argc, const char **argv)
+{
+ printf ("%d\n", s.b[0].p[0][-1]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,34 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+int mpx_test (int argc, const char **argv)
+{
+ printf ("%d\n", s.b[0].p[0][0]);
+ printf ("%d\n", s.b[0].p[0][99]);
+ printf ("%d\n", s.b[0].p[1][0]);
+ printf ("%d\n", s.b[0].p[1][199]);
+ printf ("%d\n", s.b[1].p[0][0]);
+ printf ("%d\n", s.b[1].p[0][199]);
+ printf ("%d\n", s.b[1].p[1][0]);
+ printf ("%d\n", s.b[1].p[1][99]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+int mpx_test (int argc, const char **argv)
+{
+ printf ("%d\n", s.b[0].p[0][100]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+ printf ("%d\n", s.b[0].p[0][-1]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+ printf ("%d\n", s.b[0].p[0][0]);
+ printf ("%d\n", s.b[0].p[0][99]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+ printf ("%d\n", s.b[0].p[0][100]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+char *str="dddd";
+
+int foo1 (char** ptr)
+{
+ *ptr=str;
+}
+
+int foo (char *ptr)
+{
+ char *tmp = 0;
+ foo1 (&ptr);
+ tmp = ptr;
+ return tmp[-1];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ printf ("%d\n", foo ("ddddd"));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+char *str="dddd";
+
+int foo1 (char** ptr)
+{
+ *ptr=str;
+}
+
+int foo (char *ptr)
+{
+ char *tmp = 0;
+ foo1 (&ptr);
+ tmp = ptr;
+ return tmp[0] + tmp[4];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ printf ("%d\n", foo ("ddddd"));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+char *str="dddd";
+
+int foo1 (char** ptr)
+{
+ *ptr=str;
+}
+
+int foo (char *ptr)
+{
+ char *tmp = 0;
+ foo1 (&ptr);
+ tmp = ptr;
+ return tmp[5];
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ printf ("%d\n", foo ("ddddd"));
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -51;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -50;
+
+ rd (s);
+
+ s.i1 = 50;
+ s.i2 = 49;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = 51;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, int *p5, int *p6, struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+
+ rd (buf1, buf1, buf1, buf1, buf1, buf1, s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,31 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, int *p5, int *p6, struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+
+ rd (buf1, buf1, buf1, buf1, buf1, buf1, s, 0);
+ rd (buf1, buf1, buf1, buf1, buf1, buf1, s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,32 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, int *p5, int *p6, struct s1 s, int i)
+{
+ int res = s.p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+
+ rd (buf1, buf1, buf1, buf1, buf1, buf1, s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -51;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -50;
+
+ rd (s);
+
+ s.i1 = 50;
+ s.i2 = 49;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int i1;
+ int i2;
+ int *p;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = 51;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -51;
+
+ rd (buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -50;
+
+ rd (buf1, s);
+
+ s.i1 = 50;
+ s.i2 = 49;
+
+ rd (buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = 50;
+
+ rd (buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -51;
+
+ rd (buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -50;
+
+ rd (buf1, buf1, s);
+
+ s.i1 = 50;
+ s.i2 = 49;
+
+ rd (buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = 50;
+
+ rd (buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -51;
+
+ rd (buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -50;
+
+ rd (buf1, buf1, buf1, s);
+
+ s.i1 = 50;
+ s.i2 = 49;
+
+ rd (buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = 50;
+
+ rd (buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -51;
+
+ rd (buf1, buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -50;
+
+ rd (buf1, buf1, buf1, buf1, s);
+
+ s.i1 = 50;
+ s.i2 = 49;
+
+ rd (buf1, buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = 50;
+
+ rd (buf1, buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, int *p5, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -51;
+
+ rd (buf1, buf1, buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, int *p5, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = -50;
+
+ rd (buf1, buf1, buf1, buf1, buf1, s);
+
+ s.i1 = 50;
+ s.i2 = 49;
+
+ rd (buf1, buf1, buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ int *p;
+ int i1;
+ int i2;
+} s1;
+
+int rd (int *p1, int *p2, int *p3, int *p4, int *p5, struct s1 s)
+{
+ int res = s.p[s.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.p = buf;
+ s.i1 = 50;
+ s.i2 = 50;
+
+ rd (buf1, buf1, buf1, buf1, buf1, s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1 {
+ int *p[2];
+} s1;
+
+int rd (struct s1 s, int i)
+{
+ int res = s.p[0][i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = { {buf, buf1} };
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1 {
+ int *p[2];
+} s1;
+
+int rd (struct s1 s, int i)
+{
+ int res = s.p[0][i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = { {buf, buf1} };
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1 {
+ int *p[2];
+} s1;
+
+int rd (struct s1 s, int i)
+{
+ int res = s.p[0][i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = { {buf, buf1} };
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1 {
+ int *p[2];
+} s1;
+
+int rd (struct s1 s, int i)
+{
+ int res = s.p[1][i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = { {buf, buf1} };
+
+ rd (s, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1 {
+ int *p[2];
+} s1;
+
+int rd (struct s1 s, int i)
+{
+ int res = s.p[1][i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = { {buf, buf1} };
+
+ rd (s, 0);
+ rd (s, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1 {
+ int *p[2];
+} s1;
+
+int rd (struct s1 s, int i)
+{
+ int res = s.p[1][i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s = { {buf, buf1} };
+
+ rd (s, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,31 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+int mpx_test (int argc, const char *argv[])
+{
+ struct s2 ss = s;
+
+ printf ("%d\n", ss.b[0].p[0][-1]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+int mpx_test (int argc, const char *argv[])
+{
+ struct s2 ss = s;
+
+ printf("%d\n", ss.b[0].p[0][0]);
+ printf("%d\n", ss.b[0].p[0][99]);
+ printf("%d\n", ss.b[0].p[1][0]);
+ printf("%d\n", ss.b[0].p[1][199]);
+ printf("%d\n", ss.b[1].p[0][0]);
+ printf("%d\n", ss.b[1].p[0][199]);
+ printf("%d\n", ss.b[1].p[1][0]);
+ printf("%d\n", ss.b[1].p[1][99]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,31 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+int buf1[100];
+int buf2[200];
+
+struct s1 {
+ int a;
+ int *p[2];
+} s1;
+
+struct s2 {
+ int a;
+ struct s1 b[2];
+} s2;
+
+struct s2 s = { 1, { {1, { buf1, buf2 }}, {2, { buf2, buf1} } } };
+
+int mpx_test (int argc, const char *argv[])
+{
+ struct s2 ss = s;
+
+ printf ("%d\n", ss.b[0].p[0][100]);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (void *p, int k)
+{
+ struct S *s = (struct S*)p;
+ int res = s->b[k];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo (&s.a, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,29 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (void *p, int k)
+{
+ struct S *s = (struct S*)p;
+ int res = s->b[k];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo (&s.a, 0);
+ foo (&s.a, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,30 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S {
+ int a;
+ int b[100];
+ int c;
+} S;
+
+int foo (void *p, int k)
+{
+ struct S *s = (struct S*)p;
+ int res = s->b[k];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S s;
+
+ foo (&s.a, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,33 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-lpthread" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "pthread.h"
+
+__thread int prebuf[100];
+__thread int buf[100];
+__thread int postbuf[100];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf("%d\n", res);
+ return res;
+}
+
+void *thred_func (void *ptr)
+{
+ rd (buf, -1);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ pthread_t thread;
+ pthread_create (&thread, NULL, thred_func, 0);
+ pthread_join (thread, NULL);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,33 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-lpthread" } */
+
+
+#include "mpx-check.h"
+#include "pthread.h"
+
+__thread int prebuf[100];
+__thread int buf[100];
+__thread int postbuf[100];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf("%d\n", res);
+ return res;
+}
+
+void *thred_func (void *ptr)
+{
+ rd (buf, 0);
+ rd (buf, 99);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ pthread_t thread;
+ pthread_create (&thread, NULL, thred_func, 0);
+ pthread_join (thread, NULL);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,33 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-lpthread" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "pthread.h"
+
+__thread int prebuf[100];
+__thread int buf[100];
+__thread int postbuf[100];
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf("%d\n", res);
+ return res;
+}
+
+void *thred_func (void *ptr)
+{
+ rd (buf, 100);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ pthread_t thread;
+ pthread_create (&thread, NULL, thred_func, 0);
+ pthread_join (thread, NULL);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,42 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ union {
+ int i1;
+ int i3;
+ } v;
+ int i2;
+ union {
+ int *p;
+ int p2;
+ } u;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.u.p[s.v.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.u.p = buf;
+ s.v.i1 = 50;
+ s.i2 = -51;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,45 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct s1
+{
+ union {
+ int i1;
+ int i3;
+ } v;
+ int i2;
+ union {
+ int *p;
+ int p2;
+ } u;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.u.p[s.v.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.u.p = buf;
+ s.v.i1 = 50;
+ s.i2 = -50;
+
+ rd (s);
+
+ s.v.i1 = 50;
+ s.i2 = 49;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,42 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct s1
+{
+ union {
+ int i1;
+ int i3;
+ } v;
+ int i2;
+ union {
+ int *p;
+ int p2;
+ } u;
+} s1;
+
+int rd (struct s1 s)
+{
+ int res = s.u.p[s.v.i1 + s.i2];
+ printf ("%d\n", res);
+ return res;
+}
+
+int buf[100];
+int buf1[10];
+
+int mpx_test (int argc, const char **argv)
+{
+ struct s1 s;
+ s.u.p = buf;
+ s.v.i1 = 50;
+ s.i2 = 50;
+
+ rd (s);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,41 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-Wno-attributes" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int
+foo2 (int i1, int *p1, ...)
+{
+ va_list argp;
+ int i;
+ int res;
+
+ va_start(argp, p1);
+ i = va_arg(argp, int);
+
+ res = p1[i + i1];
+ printf("%d\n", res);
+
+ return res;
+}
+
+static __attribute__((always_inline)) int
+foo1 (int *p1, ...)
+{
+ return foo2 (10, p1, __va_arg_pack ());
+}
+
+int prebuf[100];
+int buf[100];
+int postbuf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ foo1 (buf, -11);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-Wno-attributes" } */
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int
+foo2 (int i1, int *p1, ...)
+{
+ va_list argp;
+ int i;
+ int res;
+
+ va_start(argp, p1);
+ i = va_arg(argp, int);
+
+ res = p1[i + i1];
+ printf("%d\n", res);
+
+ return res;
+}
+
+static __attribute__((always_inline)) int
+foo1 (int *p1, ...)
+{
+ return foo2 (10, p1, __va_arg_pack ());
+}
+
+int prebuf[100];
+int buf[100];
+int postbuf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ foo1 (buf, 89);
+ foo1 (buf, -9);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,41 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-Wno-attributes" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int
+foo2 (int i1, int *p1, ...)
+{
+ va_list argp;
+ int i;
+ int res;
+
+ va_start(argp, p1);
+ i = va_arg(argp, int);
+
+ res = p1[i + i1];
+ printf("%d\n", res);
+
+ return res;
+}
+
+static __attribute__((always_inline)) int
+foo1 (int *p1, ...)
+{
+ return foo2 (10, p1, __va_arg_pack ());
+}
+
+int prebuf[100];
+int buf[100];
+int postbuf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ foo1 (buf, 90);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,44 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-Wno-attributes" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int
+foo2 (int i1, int *p1, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start(argp, p1);
+ p = va_arg(argp, int *);
+ i = va_arg(argp, int);
+
+ res = p[i + i1];
+ printf("%d\n", res);
+
+ return res;
+}
+
+static __attribute__((always_inline)) int
+foo1 (int *p1, ...)
+{
+ return foo2 (10, p1, __va_arg_pack ());
+}
+
+int prebuf[100];
+int buf[100];
+int buf1[100];
+int postbuf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ foo1 (buf, buf1, -11);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,43 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-Wno-attributes" } */
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int
+foo2 (int i1, int *p1, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start(argp, p1);
+ p = va_arg(argp, int *);
+ i = va_arg(argp, int);
+
+ res = p[i + i1];
+ printf("%d\n", res);
+
+ return res;
+}
+
+static __attribute__((always_inline)) int
+foo1 (int *p1, ...)
+{
+ return foo2 (10, p1, __va_arg_pack ());
+}
+
+int prebuf[100];
+int buf[100];
+int buf1[100];
+int postbuf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ foo1 (buf, buf1, 89);
+ foo1 (buf, buf1, -9);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,44 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+/* { dg-additional-options "-Wno-attributes" } */
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int
+foo2 (int i1, int *p1, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start(argp, p1);
+ p = va_arg(argp, int *);
+ i = va_arg(argp, int);
+
+ res = p[i + i1];
+ printf("%d\n", res);
+
+ return res;
+}
+
+static __attribute__((always_inline)) int
+foo1 (int *p1, ...)
+{
+ return foo2 (10, p1, __va_arg_pack ());
+}
+
+int prebuf[100];
+int buf[100];
+int buf1[100];
+int postbuf[100];
+
+int mpx_test (int argc, const char **argv)
+{
+ foo1 (buf, buf1, 90);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 0, buf, -1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 0, buf, 0);
+ rd (buf1, 0, buf, 99);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 0, buf, 100);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 1, buf1, buf, -1, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 1, buf1, buf, 0, buf1);
+ rd (buf1, 1, buf1, buf, 99, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 1, buf1, buf, 100, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 2, buf1, buf1, buf, -1, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 2, buf1, buf1, buf, 0, buf1);
+ rd (buf1, 2, buf1, buf1, buf, 99, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 2, buf1, buf1, buf, 100, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 3, buf1, buf1, buf1, buf, -1, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 3, buf1, buf1, buf1, buf, 0, buf1);
+ rd (buf1, 3, buf1, buf1, buf1, buf, 99, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 3, buf1, buf1, buf1, buf, 100, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 4, buf1, buf1, buf1, buf1, buf, -1, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 4, buf1, buf1, buf1, buf1, buf, 0, buf1);
+ rd (buf1, 4, buf1, buf1, buf1, buf1, buf, 99, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int
+rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 4, buf1, buf1, buf1, buf1, buf, 100, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pp, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+ int n = 4;
+
+ va_start (argp, pp);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, buf1, buf1, buf1, buf1, buf, -1, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pp, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+ int n = 4;
+
+ va_start (argp, pp);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, buf1, buf1, buf1, buf1, buf, 0, buf1);
+ rd (buf1, buf1, buf1, buf1, buf1, buf, 99, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,37 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pp, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+ int n = 4;
+
+ va_start (argp, pp);
+ for (; n > 0; n--)
+ va_arg (argp, int *);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, buf1, buf1, buf1, buf1, buf, 100, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, double);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 2, 10.0d, 10.0d, buf, -1, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, double);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 2, 10.0d, 10.0d, buf, 0, buf1);
+ rd (buf1, 2, 10.0d, 10.0d, buf, 99, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,36 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include "stdarg.h"
+
+int buf[100];
+int buf1[10];
+
+int rd (int *pppp, int n, ...)
+{
+ va_list argp;
+ int *p;
+ int i;
+ int res;
+
+ va_start (argp, n);
+ for (; n > 0; n--)
+ va_arg (argp, double);
+ p = va_arg (argp, int *);
+ i = va_arg (argp, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ rd (buf1, 2, 10.0d, 10.0d, buf, 100, buf1);
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int buf[100];
+int buf1[10];
+
+void vararg (int *p, va_list al)
+{
+ int i;
+ int res;
+
+ p = va_arg (al, int *);
+ i = va_arg (al, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+}
+
+void foo (int *p, ...)
+{
+ va_list args;
+
+ va_start (args, p);
+ vararg (p, args);
+ va_end (args);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (buf1, buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,38 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int buf[100];
+int buf1[10];
+
+void vararg (int *p, va_list al)
+{
+ int i;
+ int res;
+
+ p = va_arg (al, int *);
+ i = va_arg (al, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+}
+
+void foo (int *p, ...)
+{
+ va_list args;
+
+ va_start (args, p);
+ vararg (p, args);
+ va_end (args);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (buf1, buf, 0);
+ foo (buf1, buf, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,39 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+#include <stdarg.h>
+
+int buf[100];
+int buf1[10];
+
+void vararg (int *p, va_list al)
+{
+ int i;
+ int res;
+
+ p = va_arg (al, int *);
+ i = va_arg (al, int);
+
+ res = p[i];
+ printf ("%d\n", res);
+}
+
+void foo (int *p, ...)
+{
+ va_list args;
+
+ va_start (args, p);
+ vararg (p, args);
+ va_end (args);
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ foo (buf1, buf, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S
+{
+ int a;
+ int p[0];
+};
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S *s = (struct S *)alloca (sizeof(struct S) + sizeof (int)*100);
+ rd (s->p, -2);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,27 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct S
+{
+ int a;
+ int p[0];
+};
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S *s = (struct S *)alloca (sizeof(struct S) + sizeof (int)*100);
+ rd (s->p, 0);
+ rd (s->p, 99);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,28 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct S
+{
+ int a;
+ int p[0];
+};
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv)
+{
+ struct S *s = (struct S *)alloca (sizeof(struct S) + sizeof (int)*100);
+ rd (s->p, 100);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct Foo {
+ int buf[10] __attribute__((bnd_variable_size));
+};
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv) {
+ struct Foo *foo = (struct Foo *) alloca (20 * sizeof(int));
+
+ rd (foo->buf, -1);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,25 @@
+/* { dg-do run } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#include "mpx-check.h"
+
+struct Foo {
+ int buf[10] __attribute__((bnd_variable_size));
+};
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv) {
+ struct Foo *foo = (struct Foo *) alloca (20 * sizeof(int));
+
+ rd (foo->buf, 0);
+ rd (foo->buf, 19);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,26 @@
+/* { dg-do run { xfail *-*-* } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+
+#define XFAIL
+
+#include "mpx-check.h"
+
+struct Foo {
+ int buf[10] __attribute__((bnd_variable_size));
+};
+
+int rd (int *p, int i)
+{
+ int res = p[i];
+ printf ("%d\n", res);
+ return res;
+}
+
+int mpx_test (int argc, const char **argv) {
+ struct Foo *foo = (struct Foo *) alloca (20 * sizeof(int));
+
+ rd (foo->buf, 20);
+
+ return 0;
+}
new file mode 100644
@@ -0,0 +1,24 @@
+# Copyright (C) 2012-2013 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3. If not see
+# <http://www.gnu.org/licenses/>.
+
+# Return 1 if compilation with -fmpx is error-free for trivial
+# code, 0 otherwise.
+
+proc check_effective_target_mpx {} {
+ return [check_no_compiler_messages mpx object {
+ int *foo (int *arg) { return arg; }
+ } "-fcheck-pointer-bounds -mmpx"]
+}