This commit was manufactured by cvs2svn to create branch 'cfo-branch'.

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/cfo-branch@102274 138bc75d-0d04-0410-961f-82ee72b054a4

9 files changed, 222 insertions, 0 deletions

diff --git a/libmudflap/testsuite/libmudflap.c/externs-1.c b/libmudflap/testsuite/libmudflap.c/externs-1.c
new file mode 100644
index 00000000000..028f5eb5a48
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/externs-1.c
@@ -0,0 +1,16 @@
+typedef struct { char *name; } dummy;
+extern dummy d[];
+
+int
+main (void)
+{
+  dummy *pd = d;
+
+  while (pd->name)
+    {
+      printf ("%s\n", pd->name);
+      pd++;
+    }
+
+  return 0;
+}
diff --git a/libmudflap/testsuite/libmudflap.c/externs-2.c b/libmudflap/testsuite/libmudflap.c/externs-2.c
new file mode 100644
index 00000000000..cecf6253a6a
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/externs-2.c
@@ -0,0 +1,2 @@
+typedef struct { char *name; } dummy;
+dummy d[] = { {"a"}, {0} };
diff --git a/libmudflap/testsuite/libmudflap.c/externs.exp b/libmudflap/testsuite/libmudflap.c/externs.exp
new file mode 100644
index 00000000000..e97e0b684e4
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/externs.exp
@@ -0,0 +1,40 @@
+libmudflap-init c
+dg-init
+
+global srcdir subdir
+
+foreach flags [list {} {-static} {-O2} {-O3}] {
+    set l1 [libmudflap_target_compile "$srcdir/$subdir/externs-1.c" "externs-1.o" object {additional_flags=-fmudflap}]
+    set test "externs-1 compilation ${flags}"
+    if [string match "*mudflap cannot track unknown size extern *d*" $l1] { pass $test } { fail $test }
+
+    set l2 [libmudflap_target_compile "$srcdir/$subdir/externs-2.c" "externs-2.o" object {additional_flags=-fmudflap}]
+    set test "externs-2 compilation ${flags}"
+    if [string match "" $l2]  { pass $test } { fail $test }
+
+    set l3 [libmudflap_target_compile "externs-1.o externs-2.o" "externs-12.exe" executable {additional_flags=-fmudflap additional_flags=-lmudflap}]
+    set test "externs-12 linkage ${flags}"
+    if [string match "" $l3]  { pass $test } { fail $test }
+
+    set l4 [libmudflap_target_compile "externs-2.o externs-1.o" "externs-21.exe" executable {additional_flags=-fmudflap additional_flags=-lmudflap}]
+    set test "externs-21 linkage ${flags}"
+    if [string match "" $l3]  { pass $test } { fail $test }
+
+    setenv MUDFLAP_OPTIONS "-viol-segv"
+
+    remote_spawn host "./externs-12.exe"
+    set l5 [remote_wait host 10]
+    set test "externs-12 execution ${flags}"
+    if {[lindex $l5 0] == 0}  { pass $test } { fail $test }
+
+    remote_spawn host "./externs-21.exe"
+    set l6 [remote_wait host 10]
+    set test "externs-21 execution ${flags}"
+    if {[lindex $l6 0] == 0}  { pass $test } { fail $test }
+
+    foreach f [glob -nocomplain "externs-*"] {
+       remote_file build delete $f
+    }
+}
+
+dg-finish
diff --git a/libmudflap/testsuite/libmudflap.c/fail36-frag.c b/libmudflap/testsuite/libmudflap.c/fail36-frag.c
new file mode 100644
index 00000000000..af6851c1d23
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/fail36-frag.c
@@ -0,0 +1,23 @@
+#include <stdlib.h>
+
+struct k
+{
+  int p;
+  struct {
+    int m : 31;
+  } q;
+};
+
+int
+main ()
+{
+  volatile struct k *l = malloc (sizeof (int)); /* make it only big enough for k.p */
+  /* Confirm that we instrument this nested construct
+     BIT_FIELD_REF(COMPONENT_REF(INDIRECT_REF)). */
+  l->q.m = 5;
+  return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*" } */
+/* { dg-do run { xfail *-*-* } } */
diff --git a/libmudflap/testsuite/libmudflap.c/fail37-frag.c b/libmudflap/testsuite/libmudflap.c/fail37-frag.c
new file mode 100644
index 00000000000..41ce4b91e05
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/fail37-frag.c
@@ -0,0 +1,22 @@
+typedef struct
+{
+  short f : 3;
+} small;
+
+struct
+{
+  int i;
+  small s[4];
+} x;
+
+main ()
+{
+  int i;
+  for (i = 0; i < 5; i++)
+    x.s[i].f = 0;
+  exit (0);
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.* x.*" } */
+/* { dg-do run { xfail *-*-* } } */
diff --git a/libmudflap/testsuite/libmudflap.c/fail38-frag.c b/libmudflap/testsuite/libmudflap.c/fail38-frag.c
new file mode 100644
index 00000000000..9667e213418
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/fail38-frag.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct a {
+  int x;
+  int y;
+  int z : 10;
+};
+
+struct b {
+  int x;
+  int y;
+};
+
+volatile struct b k;
+volatile struct a *p;
+
+p = (struct a*) &k;
+
+p->z = 'q';
+
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. k.*" } */
+/* { dg-do run { xfail *-*-* } } */
diff --git a/libmudflap/testsuite/libmudflap.c/fail39-frag.c b/libmudflap/testsuite/libmudflap.c/fail39-frag.c
new file mode 100644
index 00000000000..4e74ea5cd5e
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/fail39-frag.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main ()
+{
+  volatile int *k = (int *) malloc (sizeof (int));
+  volatile int l;
+  if (k == NULL) abort ();
+  *k = 5;
+  free ((void *) k);
+  __mf_set_options ("-ignore-reads");
+  l = *k; /* Should not trip, even though memory region just freed.  */
+  __mf_set_options ("-no-ignore-reads");
+  l = *k; /* Should trip now.  */
+  return 0;
+}
+/* { dg-output "mudflap violation 1.*check/read.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap dead object.*malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */
diff --git a/libmudflap/testsuite/libmudflap.c/fail40-frag.c b/libmudflap/testsuite/libmudflap.c/fail40-frag.c
new file mode 100644
index 00000000000..610be20554d
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/fail40-frag.c
@@ -0,0 +1,56 @@
+/* Test proper lookup-uncaching of large objects */
+#include "../config.h"
+
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+#endif
+
+int main ()
+{
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+#ifdef HAVE_MMAP
+  volatile unsigned char *p;
+  unsigned num = getpagesize ();
+  unsigned i;
+  int rc;
+
+  /* Get a bit of usable address space.  We really want an 2**N+1-sized object,
+     so the low/high addresses wrap when hashed into the lookup cache.  So we
+     will manually unregister the entire mmap, then re-register a slice.  */
+  p = mmap (NULL, num, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
+  if (p == NULL)
+    return 1;
+  /* Now unregister it, as if munmap was called.  But don't actually munmap, so
+     we can write into the memory.  */
+  __mf_unregister ((void *) p, num, __MF_TYPE_HEAP_I);
+
+  /* Now register it under a slightly inflated, 2**N+1 size.  */
+  __mf_register ((void *) p, num+1, __MF_TYPE_HEAP_I, "fake mmap registration");
+
+  /* Traverse array to ensure that entire lookup cache is made to point at it.  */
+  for (i=0; i<num; i++)
+    p[i] = 0;
+
+  /* Unregister it.  This should clear the entire lookup cache, even though
+     hash(low) == hash (high)  (and probably == 0) */
+  __mf_unregister ((void *) p, num+1, __MF_TYPE_HEAP_I);
+
+  /* Now touch the middle portion of the ex-array.  If the lookup cache was
+     well and truly cleaned, then this access should trap.  */
+  p[num/2] = 1;
+
+  return 0;
+#else
+  return 1;
+#endif
+}
+/* { dg-output "mudflap violation 1.*check/write.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap dead object.*fake mmap registration.*" } */
+/* { dg-do run { xfail *-*-* } } */
diff --git a/libmudflap/testsuite/libmudflap.c/pass56-frag.c b/libmudflap/testsuite/libmudflap.c/pass56-frag.c
new file mode 100644
index 00000000000..e22fc8dbfd6
--- /dev/null
+++ b/libmudflap/testsuite/libmudflap.c/pass56-frag.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main ()
+{
+  volatile int *k = (int *) malloc (sizeof (int));
+  volatile int l;
+  if (k == NULL) abort ();
+  *k = 5;
+  free ((void *) k);
+  __mf_set_options ("-ignore-reads");
+  l = *k; /* Should not trip, even though memory region just freed.  */
+  return 0;
+}