This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[libmudflap] more wrappers, fixes


Hi -

The following patch adds a few more libmudflap wrappers.
It compensates for linux glibc's tendency to set up mmap buffers
into some stdio.h files which libmudflap couldn't intercept.
It also allows some object-spanning accesses.
With all these changes, a mainline gcc itself compiled with -fmudflap
went all the way through a complete build, and it wasn't atrociously
slow either.

- FChE

2004-10-12  Frank Ch. Eigler  <fche@redhat.com>

	* configure.ac: Check for more headers, functions.
	* mf-hooks2.c (mkbuffer, unmkbuffer): New helper functions for
	tracking overridden FILE buffers.
	(fopen, setvbuf): New/revised hook functions for buffer overriding.
	(setbuf,setlinebuf,fdopen,freopen,fopen64,freopen64,fclose): Ditto.
	(fflush): Accept given NULL stream (means "all streams").
	* mf-runtime.h.in: 
	* mf-runtime.c (__mfu_check): Accept accesses that span adjacent
	HEAP/GUESS objects.
	(LOOKUP_CACHE_SIZE_MAX): Raise to 64K entries tentatively.
	(__mf_adapt_cache): Use them all.
	* testsuite/libmudflap.c/pass35-frag.c: Update warning message.
	* testsuite/libmudflap.c++/ctors.exp: Ditto.
	* testsuite/libmudflap.c/{pass51,pass52}-frag.c: New tests.
	* configure, config.h.in: Regenerated.


Index: configure.ac
===================================================================
RCS file: /cvs/gcc/gcc/libmudflap/configure.ac,v
retrieving revision 1.6
diff -u -w -p -r1.6 configure.ac
--- configure.ac	5 Oct 2004 16:15:55 -0000	1.6
+++ configure.ac	13 Oct 2004 18:23:22 -0000
@@ -61,10 +61,11 @@ enable_shared=no])
 
 AC_CHECK_HEADERS(stdint.h execinfo.h signal.h dlfcn.h dirent.h pwd.h grp.h \
   netdb.h sys/ipc.h sys/sem.h sys/shm.h sys/wait.h ctype.h mntent.h \
-  sys/socket.h netinet/in.h arpa/inet.h dlfcn.h)
+  sys/socket.h netinet/in.h arpa/inet.h dlfcn.h sys/mman.h)
 
 AC_CHECK_FUNCS(backtrace backtrace_symbols gettimeofday signal)
-AC_CHECK_FUNCS(fopen64 fseeko64 ftello64 stat64)
+AC_CHECK_FUNCS(fopen64 fseeko64 ftello64 stat64 freopen64)
+AC_CHECK_FUNCS(setbuf setbuffer setlinebuf setvbuf)
 AC_CHECK_FUNCS(strnlen memrchr strncpy memmem sethostname)
 AC_CHECK_FUNCS(__ctype_b_loc __ctype_tolower_loc __ctype_toupper_loc)
 AC_CHECK_FUNCS(getlogin cuserid getpwnam getpwuid getpwent getgrnam getgrgid getgrent)
@@ -72,7 +73,7 @@ AC_CHECK_FUNCS(getlogin_r getpwnam_r get
 AC_CHECK_FUNCS(getservent getservbyname getservbyport getaddrinfo gai_strerror)
 AC_CHECK_FUNCS(getprotoent getprotobyname getprotobynumber)
 AC_CHECK_FUNCS(getmntent setmntent addmntent)
-AC_CHECK_FUNCS(inet_ntoa)
+AC_CHECK_FUNCS(inet_ntoa mmap munmap)
 
 AC_TRY_COMPILE([#include <sys/types.h>
 #include <sys/ipc.h>
Index: mf-hooks2.c
===================================================================
RCS file: /cvs/gcc/gcc/libmudflap/mf-hooks2.c,v
retrieving revision 1.10
diff -u -w -p -r1.10 mf-hooks2.c
--- mf-hooks2.c	4 Oct 2004 17:33:54 -0000	1.10
+++ mf-hooks2.c	13 Oct 2004 18:23:22 -0000
@@ -584,6 +584,66 @@ WRAPPER2(char *, strerror, int errnum)
 }
 
 
+
+/* An auxiliary data structure for tracking the hand-made stdio
+   buffers we generate during the fopen/fopen64 hooks.  In a civilized
+   language, this would be a simple dynamically sized FILE*->char*
+   lookup table, but this is C and we get to do it by hand.  */
+struct mf_filebuffer
+{
+  FILE *file;
+  char *buffer;
+  struct mf_filebuffer *next;
+};
+static struct mf_filebuffer *mf_filebuffers = NULL;
+
+static void
+mkbuffer (FILE *f)
+{
+  /* Reset any buffer automatically provided by libc, since this may
+     have been done via mechanisms that libmudflap couldn't
+     intercept.  */
+  int rc;
+  size_t bufsize = BUFSIZ;
+  int bufmode;
+  char *buffer = malloc (bufsize);
+  struct mf_filebuffer *b = malloc (sizeof (struct mf_filebuffer));
+  assert ((buffer != NULL) && (b != NULL));
+
+  /* Link it into list.  */
+  b->file = f;
+  b->buffer = buffer;
+  b->next = mf_filebuffers;
+  mf_filebuffers = b;
+
+  /* Determine how the file is supposed to be buffered at the moment.  */
+  bufmode = fileno (f) == 2 ? _IONBF : (isatty (fileno (f)) ? _IOLBF : _IOFBF);
+
+  rc = setvbuf (f, buffer, bufmode, bufsize);
+  assert (rc == 0);
+}
+
+static void
+unmkbuffer (FILE *f)
+{
+  struct mf_filebuffer *b = mf_filebuffers;
+  struct mf_filebuffer **pb = & mf_filebuffers;
+  while (b != NULL)
+    {
+      if (b->file == f)
+        {
+          *pb = b->next;
+          free (b->buffer);
+          free (b);
+          return;
+        }
+      pb = & b->next;
+      b = b->next;
+    }
+}
+
+
+
 WRAPPER2(FILE *, fopen, const char *path, const char *mode)
 {
   size_t n;
@@ -602,6 +662,106 @@ WRAPPER2(FILE *, fopen, const char *path
     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen result");
 #endif
     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen result");
+
+    mkbuffer (p);
+  }
+
+  return p;
+}
+
+
+WRAPPER2(int, setvbuf, FILE *stream, char *buf, int mode, size_t size)
+{
+  int rc = 0;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE, "setvbuf stream");
+
+  unmkbuffer (stream);
+
+  if (buf != NULL)
+    MF_VALIDATE_EXTENT (buf, size, __MF_CHECK_WRITE, "setvbuf buffer");
+
+  /* Override the user only if it's an auto-allocated buffer request.  Otherwise
+     assume that the supplied buffer is already known to libmudflap.  */
+  if ((buf == NULL) && ((mode == _IOFBF) || (mode == _IOLBF)))
+    mkbuffer (stream);
+  else
+    rc = setvbuf (stream, buf, mode, size);
+
+  return rc;
+}
+
+
+#ifdef HAVE_SETBUF
+WRAPPER2(int, setbuf, FILE* stream, char *buf)
+{
+  return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
+}
+#endif
+
+#ifdef HAVE_SETBUFFER
+WRAPPER2(int, setbuffer, FILE* stream, char *buf, size_t sz)
+{
+  return __mfwrap_setvbuf (stream, buf, buf ? _IOFBF : _IONBF, sz);
+}
+#endif
+
+#ifdef HAVE_SETLINEBUF
+WRAPPER2(int, setlinebuf, FILE* stream)
+{
+  return __mfwrap_setvbuf(stream, NULL, _IOLBF, 0);
+}
+#endif
+
+
+
+WRAPPER2(FILE *, fdopen, int fd, const char *mode)
+{
+  size_t n;
+  FILE *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (mode);
+  MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fdopen mode");
+
+  p = fdopen (fd, mode);
+  if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+    __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fdopen result");
+#endif
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fdopen result");
+
+    mkbuffer (p);
+  }
+
+  return p;
+}
+
+
+WRAPPER2(FILE *, freopen, const char *path, const char *mode, FILE *s)
+{
+  size_t n;
+  FILE *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen path");
+
+  MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen stream");
+  unmkbuffer (s);
+
+  n = strlen (mode);
+  MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen mode");
+
+  p = freopen (path, mode, s);
+  if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+    __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen result");
+#endif
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen result");
+
+    mkbuffer (p);
   }
 
   return p;
@@ -627,6 +787,39 @@ WRAPPER2(FILE *, fopen64, const char *pa
     __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "fopen64 result");
 #endif
     MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "fopen64 result");
+
+    mkbuffer (p);
+  }
+
+  return p;
+}
+#endif
+
+
+#ifdef HAVE_FREOPEN64
+WRAPPER2(FILE *, freopen64, const char *path, const char *mode, FILE *s)
+{
+  size_t n;
+  FILE *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 path");
+
+  MF_VALIDATE_EXTENT (s, (sizeof (*s)), __MF_CHECK_WRITE, "freopen64 stream");
+  unmkbuffer (s);
+
+  n = strlen (mode);
+  MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "freopen64 mode");
+
+  p = freopen (path, mode, s);
+  if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+    __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "freopen64 result");
+#endif
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "freopen64 result");
+
+    mkbuffer (p);
   }
 
   return p;
@@ -644,6 +837,7 @@ WRAPPER2(int, fclose, FILE *stream)
 #ifdef MF_REGISTER_fopen
   __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen);
 #endif
+  unmkbuffer (stream);
 
   return resp;
 }
@@ -943,6 +1137,7 @@ WRAPPER2(int , remove, const char *path)
 WRAPPER2(int, fflush, FILE *stream)
 {
   TRACE ("%s\n", __PRETTY_FUNCTION__);
+  if (stream != NULL)
   MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
     "fflush stream");
   return fflush (stream);
@@ -1071,28 +1266,6 @@ WRAPPER2(int , mkfifo, const char *path,
 }
 
 
-WRAPPER2(int, setvbuf, FILE *stream, char *buf, int mode , size_t size)
-{
-  TRACE ("%s\n", __PRETTY_FUNCTION__);
-  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
-    "setvbuf stream");
-  if (NULL != buf)
-    MF_VALIDATE_EXTENT (buf, size, __MF_CHECK_READ, "setvbuf buf");
-  return setvbuf (stream, buf, mode, size);
-}
-
-
-WRAPPER2(void, setbuf, FILE *stream, char *buf)
-{
-  TRACE ("%s\n", __PRETTY_FUNCTION__);
-  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
-    "setbuf stream");
-  if (NULL != buf)
-    MF_VALIDATE_EXTENT (buf, BUFSIZ, __MF_CHECK_READ, "setbuf buf");
-  setbuf (stream, buf);
-}
-
-
 #ifdef HAVE_DIRENT_H
 WRAPPER2(DIR *, opendir, const char *path)
 {
Index: mf-runtime.c
===================================================================
RCS file: /cvs/gcc/gcc/libmudflap/mf-runtime.c,v
retrieving revision 1.18
diff -u -w -p -r1.18 mf-runtime.c
--- mf-runtime.c	4 Oct 2004 17:33:54 -0000	1.18
+++ mf-runtime.c	13 Oct 2004 18:23:22 -0000
@@ -160,7 +160,7 @@ static void mfsplay_tree_rebalance (mfsp
 /* Required globals.  */
 
 #define LOOKUP_CACHE_MASK_DFL 1023
-#define LOOKUP_CACHE_SIZE_MAX 4096 /* Allows max CACHE_MASK 0x0FFF */
+#define LOOKUP_CACHE_SIZE_MAX 65536 /* Allows max CACHE_MASK 0xFFFF */
 #define LOOKUP_CACHE_SHIFT_DFL 2
 
 struct __mf_cache __mf_lookup_cache [LOOKUP_CACHE_SIZE_MAX];
@@ -917,7 +917,7 @@ void __mfu_check (void *ptr, size_t sz, 
                   judgement = -1;
               }
 
-            /* We now know that the access spans one or more valid objects.  */
+            /* We now know that the access spans one or more only valid objects.  */
             if (LIKELY (judgement >= 0))
               for (i = 0; i < obj_count; i++)
                 {
@@ -931,12 +931,58 @@ void __mfu_check (void *ptr, size_t sz, 
                       entry->high = obj->high;
                       judgement = 1;
                     }
+                }
+
+            /* This access runs off the end of one valid object.  That
+                could be okay, if other valid objects fill in all the
+                holes.  We allow this only for HEAP and GUESS type
+                objects.  Accesses to STATIC and STACK variables
+                should not be allowed to span.  */
+            if (UNLIKELY ((judgement == 0) && (obj_count > 1)))
+              {
+                unsigned uncovered = 0;
+                for (i = 0; i < obj_count; i++)
+                  {
+                    __mf_object_t *obj = all_ovr_obj[i];
+                    int j, uncovered_low_p, uncovered_high_p;
+                    uintptr_t ptr_lower, ptr_higher;
+
+                    uncovered_low_p = ptr_low < obj->low;
+                    ptr_lower = CLAMPSUB (obj->low, 1);
+                    uncovered_high_p = ptr_high > obj->high;
+                    ptr_higher = CLAMPADD (obj->high, 1);
+
+                    for (j = 0; j < obj_count; j++)
+                      {
+                        __mf_object_t *obj2 = all_ovr_obj[j];
 
-                  /* XXX: Access runs off left or right side of this
-                          object.  That could be okay, if there are
-                          other objects that fill in all the holes. */
+                        if (i == j) continue;
+
+                        /* Filter out objects that cannot be spanned across.  */
+                        if (obj2->type == __MF_TYPE_STACK 
+                            || obj2->type == __MF_TYPE_STATIC)
+                          continue;
+
+                          /* Consider a side "covered" if obj2 includes
+                             the next byte on that side.  */
+                          if (uncovered_low_p
+                              && (ptr_lower >= obj2->low && ptr_lower <= obj2->high))
+                            uncovered_low_p = 0;
+                          if (uncovered_high_p
+                              && (ptr_high >= obj2->low && ptr_higher <= obj2->high))
+                            uncovered_high_p = 0;
+                      }
+                    
+                    if (uncovered_low_p || uncovered_high_p)
+                      uncovered ++;
                 }
 
+                /* Success if no overlapping objects are uncovered.  */
+                if (uncovered == 0)
+                  judgement = 1;
+                }
+
+
             if (dealloc_me != NULL)
               CALL_REAL (free, dealloc_me);
 
@@ -1413,7 +1459,7 @@ __mf_adapt_cache ()
       cache_utilization += 1.0;
   cache_utilization /= (1 + __mf_lc_mask);
 
-  new_mask |= 0x3ff; /* XXX: force a large cache.  */
+  new_mask |= 0xffff; /* XXX: force a large cache.  */
   new_mask &= (LOOKUP_CACHE_SIZE_MAX - 1);
 
   VERBOSE_TRACE ("adapt cache obj=%u/%u sizes=%lu/%.0f/%.0f => "
Index: mf-runtime.h.in
===================================================================
RCS file: /cvs/gcc/gcc/libmudflap/mf-runtime.h.in,v
retrieving revision 1.7
diff -u -w -p -r1.7 mf-runtime.h.in
--- mf-runtime.h.in	4 Oct 2004 17:33:54 -0000	1.7
+++ mf-runtime.h.in	13 Oct 2004 18:23:22 -0000
@@ -108,6 +108,8 @@ extern int __mf_set_options (const char 
 #pragma redefine_extname time __mfwrap_time
 #pragma redefine_extname strerror __mfwrap_strerror
 #pragma redefine_extname fopen __mfwrap_fopen
+#pragma redefine_extname fdopen __mfwrap_fdopen
+#pragma redefine_extname freopen __mfwrap_freopen
 #pragma redefine_extname fclose __mfwrap_fclose
 #pragma redefine_extname fread __mfwrap_fread
 #pragma redefine_extname fwrite __mfwrap_fwrite
@@ -146,6 +148,8 @@ extern int __mf_set_options (const char 
 #pragma redefine_extname mkfifo __mfwrap_mkfifo
 #pragma redefine_extname setvbuf __mfwrap_setvbuf
 #pragma redefine_extname setbuf __mfwrap_setbuf
+#pragma redefine_extname setbuffer __mfwrap_setbuffer
+#pragma redefine_extname setlinebuf __mfwrap_setlinebuf
 #pragma redefine_extname opendir __mfwrap_opendir
 #pragma redefine_extname closedir __mfwrap_closedir
 #pragma redefine_extname readdir __mfwrap_readdir
@@ -176,6 +180,7 @@ extern int __mf_set_options (const char 
 #pragma redefine_extname dlsym __mfwrap_dlsym
 #pragma redefine_extname dlclose __mfwrap_dlclose
 #pragma redefine_extname fopen64 __mfwrap_fopen64
+#pragma redefine_extname freopen64 __mfwrap_freopen64
 #pragma redefine_extname stat64 __mfwrap_stat64
 #pragma redefine_extname fseeko64 __mfwrap_fseeko64
 #pragma redefine_extname ftello64 __mfwrap_ftello64
Index: testsuite/libmudflap.c/pass35-frag.c
===================================================================
RCS file: /cvs/gcc/gcc/libmudflap/testsuite/libmudflap.c/pass35-frag.c,v
retrieving revision 1.3
diff -u -w -p -r1.3 pass35-frag.c
--- testsuite/libmudflap.c/pass35-frag.c	15 Sep 2004 20:48:10 -0000	1.3
+++ testsuite/libmudflap.c/pass35-frag.c	13 Oct 2004 18:23:22 -0000
@@ -3,7 +3,7 @@
 #include <string.h>
 
 extern char end [];   /* Any old symbol we're sure will be defined. */
-/* { dg-warning "cannot track lifetime of 'end'" "cannot track lifetime" { target *-*-* } 0 } */
+/* { dg-warning "cannot track unknown size extern 'end'" "cannot track unknown size extern" { target *-*-* } 0 } */
 
 int main ()
 {
Index: testsuite/libmudflap.c/pass51-frag.c
===================================================================
RCS file: testsuite/libmudflap.c/pass51-frag.c
diff -N testsuite/libmudflap.c/pass51-frag.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ testsuite/libmudflap.c/pass51-frag.c	13 Oct 2004 18:23:22 -0000
@@ -0,0 +1,41 @@
+/* Test object-spanning accesses.  This is most conveniently done with
+   mmap, thus the config.h specificity here.  */
+#include "../config.h"
+
+#include <unistd.h>
+#include <string.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
+  void *p;
+  unsigned pg = getpagesize ();
+  int rc;
+
+  p = mmap (NULL, 4 * pg, PROT_READ|PROT_WRITE, 
+            MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
+  if (p == NULL)
+    return 1;
+
+  memset (p, 0, 4*pg);
+  rc = munmap (p, pg);
+  if (rc < 0) return 1;
+  memset (p+pg, 0, 3*pg);
+  rc = munmap (p+pg, pg);
+  if (rc < 0) return 1;
+  memset (p+2*pg, 0, 2*pg);
+  rc = munmap (p+2*pg, pg);
+  if (rc < 0) return 1;
+  memset (p+3*pg, 0, pg);
+  rc = munmap (p+3*pg, pg);
+  if (rc < 0) return 1;
+#endif
+
+  return 0;
+}
Index: testsuite/libmudflap.c/pass52-frag.c
===================================================================
RCS file: testsuite/libmudflap.c/pass52-frag.c
diff -N testsuite/libmudflap.c/pass52-frag.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ testsuite/libmudflap.c/pass52-frag.c	13 Oct 2004 18:23:22 -0000
@@ -0,0 +1,36 @@
+#include <stdio.h>
+
+
+void writestuff (FILE *f)
+{
+  fprintf (f, "hello world\n");
+  fputc ('y', f);
+  putc ('e', f);
+}
+
+void readstuff (FILE *f)
+{
+  int c, d;
+  char stuff[100], *s;
+  c = fgetc (f);
+  ungetc (c, f);
+  d = fgetc (f);
+  s = fgets (stuff, sizeof(stuff), f);
+}
+
+int main ()
+{
+  FILE *f;
+  writestuff (stdout);
+  writestuff (stderr);
+  f = fopen ("/dev/null", "w");
+  writestuff (f);
+  fclose (f);
+  f = fopen ("/dev/zero", "r");
+  readstuff (f);
+  f = freopen ("/dev/null", "w", f);
+  writestuff (f);
+  fclose (f);
+
+  return 0;
+}
Index: testsuite/libmudflap.c++/ctors.exp
===================================================================
RCS file: /cvs/gcc/gcc/libmudflap/testsuite/libmudflap.c++/ctors.exp,v
retrieving revision 1.1
diff -u -w -p -r1.1 ctors.exp
--- testsuite/libmudflap.c++/ctors.exp	9 Jul 2004 19:51:51 -0000	1.1
+++ testsuite/libmudflap.c++/ctors.exp	13 Oct 2004 18:23:22 -0000
@@ -8,7 +8,7 @@ global srcdir subdir
 foreach flags [list {} {-static} {-O2} {-O3}] {
     set l1 [libmudflap_target_compile "$srcdir/$subdir/ctors-1.cxx" "ctors-1.o" object {additional_flags=-fmudflap}]
     set test "ctors-1 compilation ${flags}"
-    if [string match "*mudflap cannot track lifetime of*k*" $l1] { pass $test } { fail $test }
+    if [string match "*mudflap cannot track unknown size extern *k*" $l1] { pass $test } { fail $test }
 
     set l2 [libmudflap_target_compile "$srcdir/$subdir/ctors-2.cxx" "ctors-2.o" object {additional_flags=-fmudflap}]
     set test "ctors-2 compilation ${flags}"


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]