Thu Nov 8 14:57:11 PST 2007

Added: llvm-gcc-4.2/trunk/libjava/verify.cc
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/verify.cc?rev=43913&view=auto

==============================================================================

--- llvm-gcc-4.2/trunk/libjava/verify.cc (added)
+++ llvm-gcc-4.2/trunk/libjava/verify.cc Thu Nov  8 16:56:19 2007
@@ -0,0 +1,3236 @@
+// verify.cc - verify bytecode
+
+/* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006  Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+// Written by Tom Tromey <tromey at redhat.com>
+
+// Define VERIFY_DEBUG to enable debugging output.
+
+#include <config.h>
+
+#include <string.h>
+
+#include <jvm.h>
+#include <gcj/cni.h>
+#include <java-insns.h>
+#include <java-interp.h>
+
+// On Solaris 10/x86, <signal.h> indirectly includes <ia32/sys/reg.h>, which 
+// defines PC since g++ predefines __EXTENSIONS__.  Undef here to avoid clash
+// with PC member of class _Jv_BytecodeVerifier below.
+#undef PC
+
+#ifdef INTERPRETER
+
+#include <java/lang/Class.h>
+#include <java/lang/VerifyError.h>
+#include <java/lang/Throwable.h>
+#include <java/lang/reflect/Modifier.h>
+#include <java/lang/StringBuffer.h>
+#include <java/lang/NoClassDefFoundError.h>
+
+#ifdef VERIFY_DEBUG
+#include <stdio.h>
+#endif /* VERIFY_DEBUG */
+
+
+// This is used to mark states which are not scheduled for
+// verification.
+#define INVALID_STATE ((state *) -1)
+
+static void debug_print (const char *fmt, ...)
+  __attribute__ ((format (printf, 1, 2)));
+
+static inline void
+debug_print (MAYBE_UNUSED const char *fmt, ...)
+{
+#ifdef VERIFY_DEBUG
+  va_list ap;
+  va_start (ap, fmt);
+  vfprintf (stderr, fmt, ap);
+  va_end (ap);
+#endif /* VERIFY_DEBUG */
+}
+
+// This started as a fairly ordinary verifier, and for the most part
+// it remains so.  It works in the obvious way, by modeling the effect
+// of each opcode as it is encountered.  For most opcodes, this is a
+// straightforward operation.
+//
+// This verifier does not do type merging.  It used to, but this
+// results in difficulty verifying some relatively simple code
+// involving interfaces, and it pushed some verification work into the
+// interpreter.
+//
+// Instead of merging reference types, when we reach a point where two
+// flows of control merge, we simply keep the union of reference types
+// from each branch.  Then, when we need to verify a fact about a
+// reference on the stack (e.g., that it is compatible with the
+// argument type of a method), we check to ensure that all possible
+// types satisfy the requirement.
+//
+// Another area this verifier differs from the norm is in its handling
+// of subroutines.  The JVM specification has some confusing things to
+// say about subroutines.  For instance, it makes claims about not
+// allowing subroutines to merge and it rejects recursive subroutines.
+// For the most part these are red herrings; we used to try to follow
+// these things but they lead to problems.  For example, the notion of
+// "being in a subroutine" is not well-defined: is an exception
+// handler in a subroutine?  If you never execute the `ret' but
+// instead `goto 1' do you remain in the subroutine?
+//
+// For clarity on what is really required for type safety, read
+// "Simple Verification Technique for Complex Java Bytecode
+// Subroutines" by Alessandro Coglio.  Among other things this paper
+// shows that recursive subroutines are not harmful to type safety.
+// We implement something similar to what he proposes.  Note that this
+// means that this verifier will accept code that is rejected by some
+// other verifiers.
+//
+// For those not wanting to read the paper, the basic observation is
+// that we can maintain split states in subroutines.  We maintain one
+// state for each calling `jsr'.  In other words, we re-verify a
+// subroutine once for each caller, using the exact types held by the
+// callers (as opposed to the old approach of merging types and
+// keeping a bitmap registering what did or did not change).  This
+// approach lets us continue to verify correctly even when a
+// subroutine is exited via `goto' or `athrow' and not `ret'.
+//
+// In some other areas the JVM specification is (mildly) incorrect,
+// so we diverge.  For instance, you cannot
+// violate type safety by allocating an object with `new' and then
+// failing to initialize it, no matter how one branches or where one
+// stores the uninitialized reference.  See "Improving the official
+// specification of Java bytecode verification" by Alessandro Coglio.
+//
+// Note that there's no real point in enforcing that padding bytes or
+// the mystery byte of invokeinterface must be 0, but we do that
+// regardless.
+//
+// The verifier is currently neither completely lazy nor eager when it
+// comes to loading classes.  It tries to represent types by name when
+// possible, and then loads them when it needs to verify a fact about
+// the type.  Checking types by name is valid because we only use
+// names which come from the current class' constant pool.  Since all
+// such names are looked up using the same class loader, there is no
+// danger that we might be fooled into comparing different types with
+// the same name.
+//
+// In the future we plan to allow for a completely lazy mode of
+// operation, where the verifier will construct a list of type
+// assertions to be checked later.
+//
+// Some test cases for the verifier live in the "verify" module of the
+// Mauve test suite.  However, some of these are presently
+// (2004-01-20) believed to be incorrect.  (More precisely the notion
+// of "correct" is not well-defined, and this verifier differs from
+// others while remaining type-safe.)  Some other tests live in the
+// libgcj test suite.
+class _Jv_BytecodeVerifier
+{
+private:
+
+  static const int FLAG_INSN_START = 1;
+  static const int FLAG_BRANCH_TARGET = 2;
+
+  struct state;
+  struct type;
+  struct linked_utf8;
+  struct ref_intersection;
+
+  template<typename T>
+  struct linked
+  {
+    T *val;
+    linked<T> *next;
+  };
+
+  // The current PC.
+  int PC;
+  // The PC corresponding to the start of the current instruction.
+  int start_PC;
+
+  // The current state of the stack, locals, etc.
+  state *current_state;
+
+  // At each branch target we keep a linked list of all the states we
+  // can process at that point.  We'll only have multiple states at a
+  // given PC if they both have different return-address types in the
+  // same stack or local slot.  This array is indexed by PC and holds
+  // the list of all such states.
+  linked<state> **states;
+
+  // We keep a linked list of all the states which we must reverify.
+  // This is the head of the list.
+  state *next_verify_state;
+
+  // We keep some flags for each instruction.  The values are the
+  // FLAG_* constants defined above.  This is an array indexed by PC.
+  char *flags;
+
+  // The bytecode itself.
+  unsigned char *bytecode;
+  // The exceptions.
+  _Jv_InterpException *exception;
+
+  // Defining class.
+  jclass current_class;
+  // This method.
+  _Jv_InterpMethod *current_method;
+
+  // A linked list of utf8 objects we allocate.
+  linked<_Jv_Utf8Const> *utf8_list;
+
+  // A linked list of all ref_intersection objects we allocate.
+  ref_intersection *isect_list;
+
+  // Create a new Utf-8 constant and return it.  We do this to avoid
+  // having our Utf-8 constants prematurely collected.
+  _Jv_Utf8Const *make_utf8_const (char *s, int len)
+  {
+    linked<_Jv_Utf8Const> *lu = (linked<_Jv_Utf8Const> *)
+      _Jv_Malloc (sizeof (linked<_Jv_Utf8Const>)
+		  + _Jv_Utf8Const::space_needed(s, len));
+    _Jv_Utf8Const *r = (_Jv_Utf8Const *) (lu + 1);
+    r->init(s, len);
+    lu->val = r;
+    lu->next = utf8_list;
+    utf8_list = lu;
+
+    return r;
+  }
+
+  __attribute__ ((__noreturn__)) void verify_fail (const char *s, jint pc = -1)
+  {
+    using namespace java::lang;
+    StringBuffer *buf = new StringBuffer ();
+
+    buf->append (JvNewStringLatin1 ("verification failed"));
+    if (pc == -1)
+      pc = start_PC;
+    if (pc != -1)
+      {
+	buf->append (JvNewStringLatin1 (" at PC "));
+	buf->append (pc);
+      }
+
+    _Jv_InterpMethod *method = current_method;
+    buf->append (JvNewStringLatin1 (" in "));
+    buf->append (current_class->getName());
+    buf->append ((jchar) ':');
+    buf->append (method->get_method()->name->toString());
+    buf->append ((jchar) '(');
+    buf->append (method->get_method()->signature->toString());
+    buf->append ((jchar) ')');
+
+    buf->append (JvNewStringLatin1 (": "));
+    buf->append (JvNewStringLatin1 (s));
+    throw new java::lang::VerifyError (buf->toString ());
+  }
+
+  // This enum holds a list of tags for all the different types we
+  // need to handle.  Reference types are treated specially by the
+  // type class.
+  enum type_val
+  {
+    void_type,
+
+    // The values for primitive types are chosen to correspond to values
+    // specified to newarray.
+    boolean_type = 4,
+    char_type = 5,
+    float_type = 6,
+    double_type = 7,
+    byte_type = 8,
+    short_type = 9,
+    int_type = 10,
+    long_type = 11,
+
+    // Used when overwriting second word of a double or long in the
+    // local variables.  Also used after merging local variable states
+    // to indicate an unusable value.
+    unsuitable_type,
+    return_address_type,
+    // This is the second word of a two-word value, i.e., a double or
+    // a long.
+    continuation_type,
+
+    // Everything after `reference_type' must be a reference type.
+    reference_type,
+    null_type,
+    uninitialized_reference_type
+  };
+
+  // This represents a merged class type.  Some verifiers (including
+  // earlier versions of this one) will compute the intersection of
+  // two class types when merging states.  However, this loses
+  // critical information about interfaces implemented by the various
+  // classes.  So instead we keep track of all the actual classes that
+  // have been merged.
+  struct ref_intersection
+  {
+    // Whether or not this type has been resolved.
+    bool is_resolved;
+
+    // Actual type data.
+    union
+    {
+      // For a resolved reference type, this is a pointer to the class.
+      jclass klass;
+      // For other reference types, this it the name of the class.
+      _Jv_Utf8Const *name;
+    } data;
+
+    // Link to the next reference in the intersection.
+    ref_intersection *ref_next;
+
+    // This is used to keep track of all the allocated
+    // ref_intersection objects, so we can free them.
+    // FIXME: we should allocate these in chunks.
+    ref_intersection *alloc_next;
+
+    ref_intersection (jclass klass, _Jv_BytecodeVerifier *verifier)
+      : ref_next (NULL)
+    {
+      is_resolved = true;
+      data.klass = klass;
+      alloc_next = verifier->isect_list;
+      verifier->isect_list = this;
+    }
+
+    ref_intersection (_Jv_Utf8Const *name, _Jv_BytecodeVerifier *verifier)
+      : ref_next (NULL)
+    {
+      is_resolved = false;
+      data.name = name;
+      alloc_next = verifier->isect_list;
+      verifier->isect_list = this;
+    }
+
+    ref_intersection (ref_intersection *dup, ref_intersection *tail,
+		      _Jv_BytecodeVerifier *verifier)
+      : ref_next (tail)
+    {
+      is_resolved = dup->is_resolved;
+      data = dup->data;
+      alloc_next = verifier->isect_list;
+      verifier->isect_list = this;
+    }
+
+    bool equals (ref_intersection *other, _Jv_BytecodeVerifier *verifier)
+    {
+      if (! is_resolved && ! other->is_resolved
+	  && _Jv_equalUtf8Classnames (data.name, other->data.name))
+	return true;
+      if (! is_resolved)
+	resolve (verifier);
+      if (! other->is_resolved)
+	other->resolve (verifier);
+      return data.klass == other->data.klass;
+    }
+
+    // Merge THIS type into OTHER, returning the result.  This will
+    // return OTHER if all the classes in THIS already appear in
+    // OTHER.
+    ref_intersection *merge (ref_intersection *other,
+			     _Jv_BytecodeVerifier *verifier)
+    {
+      ref_intersection *tail = other;
+      for (ref_intersection *self = this; self != NULL; self = self->ref_next)
+	{
+	  bool add = true;
+	  for (ref_intersection *iter = other; iter != NULL;
+	       iter = iter->ref_next)
+	    {
+	      if (iter->equals (self, verifier))
+		{
+		  add = false;
+		  break;
+		}
+	    }
+
+	  if (add)
+	    tail = new ref_intersection (self, tail, verifier);
+	}
+      return tail;
+    }
+
+    void resolve (_Jv_BytecodeVerifier *verifier)
+    {
+      if (is_resolved)
+	return;
+
+      // This is useful if you want to see which classes have to be resolved
+      // while doing the class verification.
+      debug_print("resolving class: %s\n", data.name->chars());
+
+      using namespace java::lang;
+      java::lang::ClassLoader *loader
+	= verifier->current_class->getClassLoaderInternal();
+
+      // Due to special handling in to_array() array classes will always
+      // be of the "L ... ;" kind. The separator char ('.' or '/' may vary
+      // however.
+      if (data.name->limit()[-1] == ';')
+	{
+	  data.klass = _Jv_FindClassFromSignature (data.name->chars(), loader);
+	  if (data.klass == NULL)
+	    throw new java::lang::NoClassDefFoundError(data.name->toString());
+	}
+      else
+	data.klass = Class::forName (_Jv_NewStringUtf8Const (data.name),
+				     false, loader);
+      is_resolved = true;
+    }
+
+    // See if an object of type OTHER can be assigned to an object of
+    // type *THIS.  This might resolve classes in one chain or the
+    // other.
+    bool compatible (ref_intersection *other,
+		     _Jv_BytecodeVerifier *verifier)
+    {
+      ref_intersection *self = this;
+
+      for (; self != NULL; self = self->ref_next)
+	{
+	  ref_intersection *other_iter = other;
+
+	  for (; other_iter != NULL; other_iter = other_iter->ref_next)
+	    {
+	      // Avoid resolving if possible.
+	      if (! self->is_resolved
+		  && ! other_iter->is_resolved
+		  && _Jv_equalUtf8Classnames (self->data.name,
+		 			      other_iter->data.name))
+		continue;
+
+	      if (! self->is_resolved)
+		self->resolve(verifier);
+
+              // If the LHS of the expression is of type
+              // java.lang.Object, assignment will succeed, no matter
+              // what the type of the RHS is. Using this short-cut we
+              // don't need to resolve the class of the RHS at
+              // verification time.
+              if (self->data.klass == &java::lang::Object::class$)
+                continue;
+
+	      if (! other_iter->is_resolved)
+		other_iter->resolve(verifier);
+
+	      if (! is_assignable_from_slow (self->data.klass,
+					     other_iter->data.klass))
+		return false;
+	    }
+	}
+
+      return true;
+    }
+
+    bool isarray ()
+    {
+      // assert (ref_next == NULL);
+      if (is_resolved)
+	return data.klass->isArray ();
+      else
+	return data.name->first() == '[';
+    }
+
+    bool isinterface (_Jv_BytecodeVerifier *verifier)
+    {
+      // assert (ref_next == NULL);
+      if (! is_resolved)
+	resolve (verifier);
+      return data.klass->isInterface ();
+    }
+
+    bool isabstract (_Jv_BytecodeVerifier *verifier)
+    {
+      // assert (ref_next == NULL);
+      if (! is_resolved)
+	resolve (verifier);
+      using namespace java::lang::reflect;
+      return Modifier::isAbstract (data.klass->getModifiers ());
+    }
+
+    jclass getclass (_Jv_BytecodeVerifier *verifier)
+    {
+      if (! is_resolved)
+	resolve (verifier);
+      return data.klass;
+    }
+
+    int count_dimensions ()
+    {
+      int ndims = 0;
+      if (is_resolved)
+	{
+	  jclass k = data.klass;
+	  while (k->isArray ())
+	    {
+	      k = k->getComponentType ();
+	      ++ndims;
+	    }
+	}
+      else
+	{
+	  char *p = data.name->chars();
+	  while (*p++ == '[')
+	    ++ndims;
+	}
+      return ndims;
+    }
+
+    void *operator new (size_t bytes)
+    {
+      return _Jv_Malloc (bytes);
+    }
+
+    void operator delete (void *mem)
+    {
+      _Jv_Free (mem);
+    }
+  };
+
+  // Return the type_val corresponding to a primitive signature
+  // character.  For instance `I' returns `int.class'.
+  type_val get_type_val_for_signature (jchar sig)
+  {
+    type_val rt;
+    switch (sig)
+      {
+      case 'Z':
+	rt = boolean_type;
+	break;
+      case 'B':
+	rt = byte_type;
+	break;
+      case 'C':
+	rt = char_type;
+	break;
+      case 'S':
+	rt = short_type;
+	break;
+      case 'I':
+	rt = int_type;
+	break;
+      case 'J':
+	rt = long_type;
+	break;
+      case 'F':
+	rt = float_type;
+	break;
+      case 'D':
+	rt = double_type;
+	break;
+      case 'V':
+	rt = void_type;
+	break;
+      default:
+	verify_fail ("invalid signature");
+      }
+    return rt;
+  }
+
+  // Return the type_val corresponding to a primitive class.
+  type_val get_type_val_for_signature (jclass k)
+  {
+    return get_type_val_for_signature ((jchar) k->method_count);
+  }
+
+  // This is like _Jv_IsAssignableFrom, but it works even if SOURCE or
+  // TARGET haven't been prepared.
+  static bool is_assignable_from_slow (jclass target, jclass source)
+  {
+    // First, strip arrays.
+    while (target->isArray ())
+      {
+	// If target is array, source must be as well.
+	if (! source->isArray ())
+	  return false;
+	target = target->getComponentType ();
+	source = source->getComponentType ();
+      }
+
+    // Quick success.
+    if (target == &java::lang::Object::class$)
+      return true;
+
+    do
+      {
+	if (source == target)
+	  return true;
+
+	if (target->isPrimitive () || source->isPrimitive ())
+	  return false;
+
+	if (target->isInterface ())
+	  {
+	    for (int i = 0; i < source->interface_count; ++i)
+	      {
+		// We use a recursive call because we also need to
+		// check superinterfaces.
+		if (is_assignable_from_slow (target, source->getInterface (i)))
+		  return true;
+	      }
+	  }
+	source = source->getSuperclass ();
+      }
+    while (source != NULL);
+
+    return false;
+  }
+
+  // The `type' class is used to represent a single type in the
+  // verifier.
+  struct type
+  {
+    // The type key.
+    type_val key;
+
+    // For reference types, the representation of the type.
+    ref_intersection *klass;
+
+    // This is used in two situations.
+    //
+    // First, when constructing a new object, it is the PC of the
+    // `new' instruction which created the object.  We use the special
+    // value UNINIT to mean that this is uninitialized.  The special
+    // value SELF is used for the case where the current method is
+    // itself the <init> method.  the special value EITHER is used
+    // when we may optionally allow either an uninitialized or
+    // initialized reference to match.
+    //
+    // Second, when the key is return_address_type, this holds the PC
+    // of the instruction following the `jsr'.
+    int pc;
+
+    static const int UNINIT = -2;
+    static const int SELF = -1;
+    static const int EITHER = -3;
+
+    // Basic constructor.
+    type ()
+    {
+      key = unsuitable_type;
+      klass = NULL;
+      pc = UNINIT;
+    }
+
+    // Make a new instance given the type tag.  We assume a generic
+    // `reference_type' means Object.
+    type (type_val k)
+    {
+      key = k;
+      // For reference_type, if KLASS==NULL then that means we are
+      // looking for a generic object of any kind, including an
+      // uninitialized reference.
+      klass = NULL;
+      pc = UNINIT;
+    }
+
+    // Make a new instance given a class.
+    type (jclass k, _Jv_BytecodeVerifier *verifier)
+    {
+      key = reference_type;
+      klass = new ref_intersection (k, verifier);
+      pc = UNINIT;
+    }
+
+    // Make a new instance given the name of a class.
+    type (_Jv_Utf8Const *n, _Jv_BytecodeVerifier *verifier)
+    {
+      key = reference_type;
+      klass = new ref_intersection (n, verifier);
+      pc = UNINIT;
+    }
+
+    // Copy constructor.
+    type (const type &t)
+    {
+      key = t.key;
+      klass = t.klass;
+      pc = t.pc;
+    }
+
+    // These operators are required because libgcj can't link in
+    // -lstdc++.
+    void *operator new[] (size_t bytes)
+    {
+      return _Jv_Malloc (bytes);
+    }
+
+    void operator delete[] (void *mem)
+    {
+      _Jv_Free (mem);
+    }
+
+    type& operator= (type_val k)
+    {
+      key = k;
+      klass = NULL;
+      pc = UNINIT;
+      return *this;
+    }
+
+    type& operator= (const type& t)
+    {
+      key = t.key;
+      klass = t.klass;
+      pc = t.pc;
+      return *this;
+    }
+
+    // Promote a numeric type.
+    type &promote ()
+    {
+      if (key == boolean_type || key == char_type
+	  || key == byte_type || key == short_type)
+	key = int_type;
+      return *this;
+    }
+
+    // Mark this type as the uninitialized result of `new'.
+    void set_uninitialized (int npc, _Jv_BytecodeVerifier *verifier)
+    {
+      if (key == reference_type)
+	key = uninitialized_reference_type;
+      else
+	verifier->verify_fail ("internal error in type::uninitialized");
+      pc = npc;
+    }
+
+    // Mark this type as now initialized.
+    void set_initialized (int npc)
+    {
+      if (npc != UNINIT && pc == npc && key == uninitialized_reference_type)
+	{
+	  key = reference_type;
+	  pc = UNINIT;
+	}
+    }
+
+    // Mark this type as a particular return address.
+    void set_return_address (int npc)
+    {
+      pc = npc;
+    }
+
+    // Return true if this type and type OTHER are considered
+    // mergeable for the purposes of state merging.  This is related
+    // to subroutine handling.  For this purpose two types are
+    // considered unmergeable if they are both return-addresses but
+    // have different PCs.
+    bool state_mergeable_p (const type &other) const
+    {
+      return (key != return_address_type
+	      || other.key != return_address_type
+	      || pc == other.pc);
+    }
+
+    // Return true if an object of type K can be assigned to a variable
+    // of type *THIS.  Handle various special cases too.  Might modify
+    // *THIS or K.  Note however that this does not perform numeric
+    // promotion.
+    bool compatible (type &k, _Jv_BytecodeVerifier *verifier)
+    {
+      // Any type is compatible with the unsuitable type.
+      if (key == unsuitable_type)
+	return true;
+
+      if (key < reference_type || k.key < reference_type)
+	return key == k.key;
+
+      // The `null' type is convertible to any initialized reference
+      // type.
+      if (key == null_type)
+	return k.key != uninitialized_reference_type;
+      if (k.key == null_type)
+	return key != uninitialized_reference_type;
+
+      // A special case for a generic reference.
+      if (klass == NULL)
+	return true;
+      if (k.klass == NULL)
+	verifier->verify_fail ("programmer error in type::compatible");
+
+      // Handle the special 'EITHER' case, which is only used in a
+      // special case of 'putfield'.  Note that we only need to handle
+      // this on the LHS of a check.
+      if (! isinitialized () && pc == EITHER)
+	{
+	  // If the RHS is uninitialized, it must be an uninitialized
+	  // 'this'.
+	  if (! k.isinitialized () && k.pc != SELF)
+	    return false;
+	}
+      else if (isinitialized () != k.isinitialized ())
+	{
+	  // An initialized type and an uninitialized type are not
+	  // otherwise compatible.
+	  return false;
+	}
+      else
+	{
+	  // Two uninitialized objects are compatible if either:
+	  // * The PCs are identical, or
+	  // * One PC is UNINIT.
+	  if (! isinitialized ())
+	    {
+	      if (pc != k.pc && pc != UNINIT && k.pc != UNINIT)
+		return false;
+	    }
+	}
+
+      return klass->compatible(k.klass, verifier);
+    }
+
+    bool equals (const type &other, _Jv_BytecodeVerifier *vfy)
+    {
+      // Only works for reference types.
+      if ((key != reference_type
+	   && key != uninitialized_reference_type)
+	  || (other.key != reference_type
+	      && other.key != uninitialized_reference_type))
+	return false;
+      // Only for single-valued types.
+      if (klass->ref_next || other.klass->ref_next)
+	return false;
+      return klass->equals (other.klass, vfy);
+    }
+
+    bool isvoid () const
+    {
+      return key == void_type;
+    }
+
+    bool iswide () const
+    {
+      return key == long_type || key == double_type;
+    }
+
+    // Return number of stack or local variable slots taken by this
+    // type.
+    int depth () const
+    {
+      return iswide () ? 2 : 1;
+    }
+
+    bool isarray () const
+    {
+      // We treat null_type as not an array.  This is ok based on the
+      // current uses of this method.
+      if (key == reference_type)
+	return klass->isarray ();
+      return false;
+    }
+
+    bool isnull () const
+    {
+      return key == null_type;
+    }
+
+    bool isinterface (_Jv_BytecodeVerifier *verifier)
+    {
+      if (key != reference_type)
+	return false;
+      return klass->isinterface (verifier);
+    }
+
+    bool isabstract (_Jv_BytecodeVerifier *verifier)
+    {
+      if (key != reference_type)
+	return false;
+      return klass->isabstract (verifier);
+    }
+
+    // Return the element type of an array.
+    type element_type (_Jv_BytecodeVerifier *verifier)
+    {
+      if (key != reference_type)
+	verifier->verify_fail ("programmer error in type::element_type()", -1);
+
+      jclass k = klass->getclass (verifier)->getComponentType ();
+      if (k->isPrimitive ())
+	return type (verifier->get_type_val_for_signature (k));
+      return type (k, verifier);
+    }
+
+    // Return the array type corresponding to an initialized
+    // reference.  We could expand this to work for other kinds of
+    // types, but currently we don't need to.
+    type to_array (_Jv_BytecodeVerifier *verifier)
+    {
+      if (key != reference_type)
+	verifier->verify_fail ("internal error in type::to_array()");
+
+      // In case the class is already resolved we can simply ask the runtime
+      // to give us the array version.
+      // If it is not resolved we prepend "[" to the classname to make the
+      // array usage verification more lazy. In other words: makes new Foo[300]
+      // pass the verifier if Foo.class is missing.
+      if (klass->is_resolved)
+        {
+          jclass k = klass->getclass (verifier);
+
+          return type (_Jv_GetArrayClass (k, k->getClassLoaderInternal()),
+		       verifier);
+        }
+      else
+        {
+          int len = klass->data.name->len();
+
+          // If the classname is given in the Lp1/p2/cn; format we only need
+          // to add a leading '['. The same procedure has to be done for
+          // primitive arrays (ie. provided "[I", the result should be "[[I".
+          // If the classname is given as p1.p2.cn we have to embed it into
+          // "[L" and ';'.
+          if (klass->data.name->limit()[-1] == ';' ||
+               _Jv_isPrimitiveOrDerived(klass->data.name))
+            {
+              // Reserves space for leading '[' and trailing '\0' .
+              char arrayName[len + 2];
+
+              arrayName[0] = '[';
+              strcpy(&arrayName[1], klass->data.name->chars());
+
+#ifdef VERIFY_DEBUG
+              // This is only needed when we want to print the string to the
+              // screen while debugging.
+              arrayName[len + 1] = '\0';
+
+              debug_print("len: %d - old: '%s' - new: '%s'\n", len, klass->data.name->chars(), arrayName);
+#endif
+
+              return type (verifier->make_utf8_const( arrayName, len + 1 ),
+                           verifier);
+            }
+           else
+            {
+              // Reserves space for leading "[L" and trailing ';' and '\0' .
+              char arrayName[len + 4];
+
+              arrayName[0] = '[';
+              arrayName[1] = 'L';
+              strcpy(&arrayName[2], klass->data.name->chars());
+              arrayName[len + 2] = ';';
+
+#ifdef VERIFY_DEBUG
+              // This is only needed when we want to print the string to the
+              // screen while debugging.
+              arrayName[len + 3] = '\0';
+
+              debug_print("len: %d - old: '%s' - new: '%s'\n", len, klass->data.name->chars(), arrayName);
+#endif
+
+              return type (verifier->make_utf8_const( arrayName, len + 3 ),
+                           verifier);
+            }
+        }
+
+    }
+
+    bool isreference () const
+    {
+      return key >= reference_type;
+    }
+
+    int get_pc () const
+    {
+      return pc;
+    }
+
+    bool isinitialized () const
+    {
+      return key == reference_type || key == null_type;
+    }
+
+    bool isresolved () const
+    {
+      return (key == reference_type
+	      || key == null_type
+	      || key == uninitialized_reference_type);
+    }
+
+    void verify_dimensions (int ndims, _Jv_BytecodeVerifier *verifier)
+    {
+      // The way this is written, we don't need to check isarray().
+      if (key != reference_type)
+	verifier->verify_fail ("internal error in verify_dimensions:"
+			       " not a reference type");
+
+      if (klass->count_dimensions () < ndims)
+	verifier->verify_fail ("array type has fewer dimensions"
+			       " than required");
+    }
+
+    // Merge OLD_TYPE into this.  On error throw exception.  Return
+    // true if the merge caused a type change.
+    bool merge (type& old_type, bool local_semantics,
+		_Jv_BytecodeVerifier *verifier)
+    {
+      bool changed = false;
+      bool refo = old_type.isreference ();
+      bool refn = isreference ();
+      if (refo && refn)
+	{
+	  if (old_type.key == null_type)
+	    ;
+	  else if (key == null_type)
+	    {
+	      *this = old_type;
+	      changed = true;
+	    }
+	  else if (isinitialized () != old_type.isinitialized ())
+	    verifier->verify_fail ("merging initialized and uninitialized types");
+	  else
+	    {
+	      if (! isinitialized ())
+		{
+		  if (pc == UNINIT)
+		    pc = old_type.pc;
+		  else if (old_type.pc == UNINIT)
+		    ;
+		  else if (pc != old_type.pc)
+		    verifier->verify_fail ("merging different uninitialized types");
+		}
+
+	      ref_intersection *merged = old_type.klass->merge (klass,
+								verifier);
+	      if (merged != klass)
+		{
+		  klass = merged;
+		  changed = true;
+		}
+	    }
+	}
+      else if (refo || refn || key != old_type.key)
+	{
+	  if (local_semantics)
+	    {
+	      // If we already have an `unsuitable' type, then we
+	      // don't need to change again.
+	      if (key != unsuitable_type)
+		{
+		  key = unsuitable_type;
+		  changed = true;
+		}
+	    }
+	  else
+	    verifier->verify_fail ("unmergeable type");
+	}
+      return changed;
+    }
+
+#ifdef VERIFY_DEBUG
+    void print (void) const
+    {
+      char c = '?';
+      switch (key)
+	{
+	case boolean_type: c = 'Z'; break;
+	case byte_type: c = 'B'; break;
+	case char_type: c = 'C'; break;
+	case short_type: c = 'S'; break;
+	case int_type: c = 'I'; break;
+	case long_type: c = 'J'; break;
+	case float_type: c = 'F'; break;
+	case double_type: c = 'D'; break;
+	case void_type: c = 'V'; break;
+	case unsuitable_type: c = '-'; break;
+	case return_address_type: c = 'r'; break;
+	case continuation_type: c = '+'; break;
+	case reference_type: c = 'L'; break;
+	case null_type: c = '@'; break;
+	case uninitialized_reference_type: c = 'U'; break;
+	}
+      debug_print ("%c", c);
+    }
+#endif /* VERIFY_DEBUG */
+  };
+
+  // This class holds all the state information we need for a given
+  // location.
+  struct state
+  {
+    // The current top of the stack, in terms of slots.
+    int stacktop;
+    // The current depth of the stack.  This will be larger than
+    // STACKTOP when wide types are on the stack.
+    int stackdepth;
+    // The stack.
+    type *stack;
+    // The local variables.
+    type *locals;
+    // We keep track of the type of `this' specially.  This is used to
+    // ensure that an instance initializer invokes another initializer
+    // on `this' before returning.  We must keep track of this
+    // specially because otherwise we might be confused by code which
+    // assigns to locals[0] (overwriting `this') and then returns
+    // without really initializing.
+    type this_type;
+
+    // The PC for this state.  This is only valid on states which are
+    // permanently attached to a given PC.  For an object like
+    // `current_state', which is used transiently, this has no
+    // meaning.
+    int pc;
+    // We keep a linked list of all states requiring reverification.
+    // If this is the special value INVALID_STATE then this state is
+    // not on the list.  NULL marks the end of the linked list.
+    state *next;
+
+    // NO_NEXT is the PC value meaning that a new state must be
+    // acquired from the verification list.
+    static const int NO_NEXT = -1;
+
+    state ()
+      : this_type ()
+    {
+      stack = NULL;
+      locals = NULL;
+      next = INVALID_STATE;
+    }
+
+    state (int max_stack, int max_locals)
+      : this_type ()
+    {
+      stacktop = 0;
+      stackdepth = 0;
+      stack = new type[max_stack];
+      for (int i = 0; i < max_stack; ++i)
+	stack[i] = unsuitable_type;
+      locals = new type[max_locals];
+      for (int i = 0; i < max_locals; ++i)
+	locals[i] = unsuitable_type;
+      pc = NO_NEXT;
+      next = INVALID_STATE;
+    }
+
+    state (const state *orig, int max_stack, int max_locals)
+    {
+      stack = new type[max_stack];
+      locals = new type[max_locals];
+      copy (orig, max_stack, max_locals);
+      pc = NO_NEXT;
+      next = INVALID_STATE;
+    }
+
+    ~state ()
+    {
+      if (stack)
+	delete[] stack;
+      if (locals)
+	delete[] locals;
+    }
+
+    void *operator new[] (size_t bytes)
+    {
+      return _Jv_Malloc (bytes);
+    }
+
+    void operator delete[] (void *mem)
+    {
+      _Jv_Free (mem);
+    }
+
+    void *operator new (size_t bytes)
+    {
+      return _Jv_Malloc (bytes);
+    }
+
+    void operator delete (void *mem)
+    {
+      _Jv_Free (mem);
+    }
+
+    void copy (const state *copy, int max_stack, int max_locals)
+    {
+      stacktop = copy->stacktop;
+      stackdepth = copy->stackdepth;
+      for (int i = 0; i < max_stack; ++i)
+	stack[i] = copy->stack[i];
+      for (int i = 0; i < max_locals; ++i)
+	locals[i] = copy->locals[i];
+
+      this_type = copy->this_type;
+      // Don't modify `next' or `pc'.
+    }
+
+    // Modify this state to reflect entry to an exception handler.
+    void set_exception (type t, int max_stack)
+    {
+      stackdepth = 1;
+      stacktop = 1;
+      stack[0] = t;
+      for (int i = stacktop; i < max_stack; ++i)
+	stack[i] = unsuitable_type;
+    }
+
+    inline int get_pc () const
+    {
+      return pc;
+    }
+
+    void set_pc (int npc)
+    {
+      pc = npc;
+    }
+
+    // Merge STATE_OLD into this state.  Destructively modifies this
+    // state.  Returns true if the new state was in fact changed.
+    // Will throw an exception if the states are not mergeable.
+    bool merge (state *state_old, int max_locals,
+		_Jv_BytecodeVerifier *verifier)
+    {
+      bool changed = false;
+
+      // Special handling for `this'.  If one or the other is
+      // uninitialized, then the merge is uninitialized.
+      if (this_type.isinitialized ())
+	this_type = state_old->this_type;
+
+      // Merge stacks.
+      if (state_old->stacktop != stacktop)  // FIXME stackdepth instead?
+	verifier->verify_fail ("stack sizes differ");
+      for (int i = 0; i < state_old->stacktop; ++i)
+	{
+	  if (stack[i].merge (state_old->stack[i], false, verifier))
+	    changed = true;
+	}
+
+      // Merge local variables.
+      for (int i = 0; i < max_locals; ++i)
+	{
+	  if (locals[i].merge (state_old->locals[i], true, verifier))
+	    changed = true;
+	}
+
+      return changed;
+    }
+
+    // Ensure that `this' has been initialized.
+    void check_this_initialized (_Jv_BytecodeVerifier *verifier)
+    {
+      if (this_type.isreference () && ! this_type.isinitialized ())
+	verifier->verify_fail ("`this' is uninitialized");
+    }
+
+    // Set type of `this'.
+    void set_this_type (const type &k)
+    {
+      this_type = k;
+    }
+
+    // Mark each `new'd object we know of that was allocated at PC as
+    // initialized.
+    void set_initialized (int pc, int max_locals)
+    {
+      for (int i = 0; i < stacktop; ++i)
+	stack[i].set_initialized (pc);
+      for (int i = 0; i < max_locals; ++i)
+	locals[i].set_initialized (pc);
+      this_type.set_initialized (pc);
+    }
+
+    // This tests to see whether two states can be considered "merge
+    // compatible".  If both states have a return-address in the same
+    // slot, and the return addresses are different, then they are not
+    // compatible and we must not try to merge them.
+    bool state_mergeable_p (state *other, int max_locals,
+			    _Jv_BytecodeVerifier *verifier)
+    {
+      // This is tricky: if the stack sizes differ, then not only are
+      // these not mergeable, but in fact we should give an error, as
+      // we've found two execution paths that reach a branch target
+      // with different stack depths.  FIXME stackdepth instead?
+      if (stacktop != other->stacktop)
+	verifier->verify_fail ("stack sizes differ");
+
+      for (int i = 0; i < stacktop; ++i)
+	if (! stack[i].state_mergeable_p (other->stack[i]))
+	  return false;
+      for (int i = 0; i < max_locals; ++i)
+	if (! locals[i].state_mergeable_p (other->locals[i]))
+	  return false;
+      return true;
+    }
+
+    void reverify (_Jv_BytecodeVerifier *verifier)
+    {
+      if (next == INVALID_STATE)
+	{
+	  next = verifier->next_verify_state;
+	  verifier->next_verify_state = this;
+	}
+    }
+
+#ifdef VERIFY_DEBUG
+    void print (const char *leader, int pc,
+		int max_stack, int max_locals) const
+    {
+      debug_print ("%s [%4d]:   [stack] ", leader, pc);
+      int i;
+      for (i = 0; i < stacktop; ++i)
+	stack[i].print ();
+      for (; i < max_stack; ++i)
+	debug_print (".");
+      debug_print ("    [local] ");
+      for (i = 0; i < max_locals; ++i)
+	locals[i].print ();
+      debug_print (" | %p\n", this);
+    }
+#else
+    inline void print (const char *, int, int, int) const
+    {
+    }
+#endif /* VERIFY_DEBUG */
+  };
+
+  type pop_raw ()
+  {
+    if (current_state->stacktop <= 0)
+      verify_fail ("stack empty");
+    type r = current_state->stack[--current_state->stacktop];
+    current_state->stackdepth -= r.depth ();
+    if (current_state->stackdepth < 0)
+      verify_fail ("stack empty", start_PC);
+    return r;
+  }
+
+  type pop32 ()
+  {
+    type r = pop_raw ();
+    if (r.iswide ())
+      verify_fail ("narrow pop of wide type");
+    return r;
+  }
+
+  type pop_type (type match)
+  {
+    match.promote ();
+    type t = pop_raw ();
+    if (! match.compatible (t, this))
+      verify_fail ("incompatible type on stack");
+    return t;
+  }
+
+  // Pop a reference which is guaranteed to be initialized.  MATCH
+  // doesn't have to be a reference type; in this case this acts like
+  // pop_type.
+  type pop_init_ref (type match)
+  {
+    type t = pop_raw ();
+    if (t.isreference () && ! t.isinitialized ())
+      verify_fail ("initialized reference required");
+    else if (! match.compatible (t, this))
+      verify_fail ("incompatible type on stack");
+    return t;
+  }
+
+  // Pop a reference type or a return address.
+  type pop_ref_or_return ()
+  {
+    type t = pop_raw ();
+    if (! t.isreference () && t.key != return_address_type)
+      verify_fail ("expected reference or return address on stack");
+    return t;
+  }
+
+  void push_type (type t)
+  {
+    // If T is a numeric type like short, promote it to int.
+    t.promote ();
+
+    int depth = t.depth ();
+    if (current_state->stackdepth + depth > current_method->max_stack)
+      verify_fail ("stack overflow");
+    current_state->stack[current_state->stacktop++] = t;
+    current_state->stackdepth += depth;
+  }
+
+  void set_variable (int index, type t)
+  {
+    // If T is a numeric type like short, promote it to int.
+    t.promote ();
+
+    int depth = t.depth ();
+    if (index > current_method->max_locals - depth)
+      verify_fail ("invalid local variable");
+    current_state->locals[index] = t;
+
+    if (depth == 2)
+      current_state->locals[index + 1] = continuation_type;
+    if (index > 0 && current_state->locals[index - 1].iswide ())
+      current_state->locals[index - 1] = unsuitable_type;
+  }
+
+  type get_variable (int index, type t)
+  {
+    int depth = t.depth ();
+    if (index > current_method->max_locals - depth)
+      verify_fail ("invalid local variable");
+    if (! t.compatible (current_state->locals[index], this))
+      verify_fail ("incompatible type in local variable");
+    if (depth == 2)
+      {
+	type t (continuation_type);
+	if (! current_state->locals[index + 1].compatible (t, this))
+	  verify_fail ("invalid local variable");
+      }
+    return current_state->locals[index];
+  }
+
+  // Make sure ARRAY is an array type and that its elements are
+  // compatible with type ELEMENT.  Returns the actual element type.
+  type require_array_type (type array, type element)
+  {
+    // An odd case.  Here we just pretend that everything went ok.  If
+    // the requested element type is some kind of reference, return
+    // the null type instead.
+    if (array.isnull ())
+      return element.isreference () ? type (null_type) : element;
+
+    if (! array.isarray ())
+      verify_fail ("array required");
+
+    type t = array.element_type (this);
+    if (! element.compatible (t, this))
+      {
+	// Special case for byte arrays, which must also be boolean
+	// arrays.
+	bool ok = true;
+	if (element.key == byte_type)
+	  {
+	    type e2 (boolean_type);
+	    ok = e2.compatible (t, this);
+	  }
+	if (! ok)
+	  verify_fail ("incompatible array element type");
+      }
+
+    // Return T and not ELEMENT, because T might be specialized.
+    return t;
+  }
+
+  jint get_byte ()
+  {
+    if (PC >= current_method->code_length)
+      verify_fail ("premature end of bytecode");
+    return (jint) bytecode[PC++] & 0xff;
+  }
+
+  jint get_ushort ()
+  {
+    jint b1 = get_byte ();
+    jint b2 = get_byte ();
+    return (jint) ((b1 << 8) | b2) & 0xffff;
+  }
+
+  jint get_short ()
+  {
+    jint b1 = get_byte ();
+    jint b2 = get_byte ();
+    jshort s = (b1 << 8) | b2;
+    return (jint) s;
+  }
+
+  jint get_int ()
+  {
+    jint b1 = get_byte ();
+    jint b2 = get_byte ();
+    jint b3 = get_byte ();
+    jint b4 = get_byte ();
+    return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
+  }
+
+  int compute_jump (int offset)
+  {
+    int npc = start_PC + offset;
+    if (npc < 0 || npc >= current_method->code_length)
+      verify_fail ("branch out of range", start_PC);
+    return npc;
+  }
+
+  // Add a new state to the state list at NPC.
+  state *add_new_state (int npc, state *old_state)
+  {
+    state *new_state = new state (old_state, current_method->max_stack,
+				  current_method->max_locals);
+    debug_print ("== New state in add_new_state\n");
+    new_state->print ("New", npc, current_method->max_stack,
+		      current_method->max_locals);
+    linked<state> *nlink
+      = (linked<state> *) _Jv_Malloc (sizeof (linked<state>));
+    nlink->val = new_state;
+    nlink->next = states[npc];
+    states[npc] = nlink;
+    new_state->set_pc (npc);
+    return new_state;
+  }
+
+  // Merge the indicated state into the state at the branch target and
+  // schedule a new PC if there is a change.  NPC is the PC of the
+  // branch target, and FROM_STATE is the state at the source of the
+  // branch.  This method returns true if the destination state
+  // changed and requires reverification, false otherwise.
+  void merge_into (int npc, state *from_state)
+  {
+    // Iterate over all target states and merge our state into each,
+    // if applicable.  FIXME one improvement we could make here is
+    // "state destruction".  Merging a new state into an existing one
+    // might cause a return_address_type to be merged to
+    // unsuitable_type.  In this case the resulting state may now be
+    // mergeable with other states currently held in parallel at this
+    // location.  So in this situation we could pairwise compare and
+    // reduce the number of parallel states.
+    bool applicable = false;
+    for (linked<state> *iter = states[npc]; iter != NULL; iter = iter->next)
+      {
+	state *new_state = iter->val;
+	if (new_state->state_mergeable_p (from_state,
+					  current_method->max_locals, this))
+	  {
+	    applicable = true;
+
+	    debug_print ("== Merge states in merge_into\n");
+	    from_state->print ("Frm", start_PC, current_method->max_stack,
+			       current_method->max_locals);
+	    new_state->print (" To", npc, current_method->max_stack,
+			      current_method->max_locals);
+	    bool changed = new_state->merge (from_state,
+					     current_method->max_locals,
+					     this);
+	    new_state->print ("New", npc, current_method->max_stack,
+			      current_method->max_locals);
+
+	    if (changed)
+	      new_state->reverify (this);
+	  }
+      }
+
+    if (! applicable)
+      {
+	// Either we don't yet have a state at NPC, or we have a
+	// return-address type that is in conflict with all existing
+	// state.  So, we need to create a new entry.
+	state *new_state = add_new_state (npc, from_state);
+	// A new state added in this way must always be reverified.
+	new_state->reverify (this);
+      }
+  }
+
+  void push_jump (int offset)
+  {
+    int npc = compute_jump (offset);
+    // According to the JVM Spec, we need to check for uninitialized
+    // objects here.  However, this does not actually affect type
+    // safety, and the Eclipse java compiler generates code that
+    // violates this constraint.
+    merge_into (npc, current_state);
+  }
+
+  void push_exception_jump (type t, int pc)
+  {
+    // According to the JVM Spec, we need to check for uninitialized
+    // objects here.  However, this does not actually affect type
+    // safety, and the Eclipse java compiler generates code that
+    // violates this constraint.
+    state s (current_state, current_method->max_stack,
+	     current_method->max_locals);
+    if (current_method->max_stack < 1)
+      verify_fail ("stack overflow at exception handler");
+    s.set_exception (t, current_method->max_stack);
+    merge_into (pc, &s);
+  }
+
+  state *pop_jump ()
+  {
+    state *new_state = next_verify_state;
+    if (new_state == INVALID_STATE)
+      verify_fail ("programmer error in pop_jump");
+    if (new_state != NULL)
+      {
+	next_verify_state = new_state->next;
+	new_state->next = INVALID_STATE;
+      }
+    return new_state;
+  }
+
+  void invalidate_pc ()
+  {
+    PC = state::NO_NEXT;
+  }
+
+  void note_branch_target (int pc)
+  {
+    // Don't check `pc <= PC', because we've advanced PC after
+    // fetching the target and we haven't yet checked the next
+    // instruction.
+    if (pc < PC && ! (flags[pc] & FLAG_INSN_START))
+      verify_fail ("branch not to instruction start", start_PC);
+    flags[pc] |= FLAG_BRANCH_TARGET;
+  }
+
+  void skip_padding ()
+  {
+    while ((PC % 4) > 0)
+      if (get_byte () != 0)
+	verify_fail ("found nonzero padding byte");
+  }
+
+  // Do the work for a `ret' instruction.  INDEX is the index into the
+  // local variables.
+  void handle_ret_insn (int index)
+  {
+    type ret_addr = get_variable (index, return_address_type);
+    // It would be nice if we could do this.  However, the JVM Spec
+    // doesn't say that this is what happens.  It is implied that
+    // reusing a return address is invalid, but there's no actual
+    // prohibition against it.
+    // set_variable (index, unsuitable_type);
+
+    int npc = ret_addr.get_pc ();
+    // We might be returning to a `jsr' that is at the end of the
+    // bytecode.  This is ok if we never return from the called
+    // subroutine, but if we see this here it is an error.
+    if (npc >= current_method->code_length)
+      verify_fail ("fell off end");
+
+    // According to the JVM Spec, we need to check for uninitialized
+    // objects here.  However, this does not actually affect type
+    // safety, and the Eclipse java compiler generates code that
+    // violates this constraint.
+    merge_into (npc, current_state);
+    invalidate_pc ();
+  }
+
+  void handle_jsr_insn (int offset)
+  {
+    int npc = compute_jump (offset);
+
+    // According to the JVM Spec, we need to check for uninitialized
+    // objects here.  However, this does not actually affect type
+    // safety, and the Eclipse java compiler generates code that
+    // violates this constraint.
+
+    // Modify our state as appropriate for entry into a subroutine.
+    type ret_addr (return_address_type);
+    ret_addr.set_return_address (PC);
+    push_type (ret_addr);
+    merge_into (npc, current_state);
+    invalidate_pc ();
+  }
+
+  jclass construct_primitive_array_type (type_val prim)
+  {
+    jclass k = NULL;
+    switch (prim)
+      {
+      case boolean_type:
+	k = JvPrimClass (boolean);
+	break;
+      case char_type:
+	k = JvPrimClass (char);
+	break;
+      case float_type:
+	k = JvPrimClass (float);
+	break;
+      case double_type:
+	k = JvPrimClass (double);
+	break;
+      case byte_type:
+	k = JvPrimClass (byte);
+	break;
+      case short_type:
+	k = JvPrimClass (short);
+	break;
+      case int_type:
+	k = JvPrimClass (int);
+	break;
+      case long_type:
+	k = JvPrimClass (long);
+	break;
+
+      // These aren't used here but we call them out to avoid
+      // warnings.
+      case void_type:
+      case unsuitable_type:
+      case return_address_type:
+      case continuation_type:
+      case reference_type:
+      case null_type:
+      case uninitialized_reference_type:
+      default:
+	verify_fail ("unknown type in construct_primitive_array_type");
+      }
+    k = _Jv_GetArrayClass (k, NULL);
+    return k;
+  }
+
+  // This pass computes the location of branch targets and also
+  // instruction starts.
+  void branch_prepass ()
+  {
+    flags = (char *) _Jv_Malloc (current_method->code_length);
+
+    for (int i = 0; i < current_method->code_length; ++i)
+      flags[i] = 0;
+
+    PC = 0;
+    while (PC < current_method->code_length)
+      {
+	// Set `start_PC' early so that error checking can have the
+	// correct value.
+	start_PC = PC;
+	flags[PC] |= FLAG_INSN_START;
+
+	java_opcode opcode = (java_opcode) bytecode[PC++];
+	switch (opcode)
+	  {
+	  case op_nop:
+	  case op_aconst_null:
+	  case op_iconst_m1:
+	  case op_iconst_0:
+	  case op_iconst_1:
+	  case op_iconst_2:
+	  case op_iconst_3:
+	  case op_iconst_4:
+	  case op_iconst_5:
+	  case op_lconst_0:
+	  case op_lconst_1:
+	  case op_fconst_0:
+	  case op_fconst_1:
+	  case op_fconst_2:
+	  case op_dconst_0:
+	  case op_dconst_1:
+	  case op_iload_0:
+	  case op_iload_1:
+	  case op_iload_2:
+	  case op_iload_3:
+	  case op_lload_0:
+	  case op_lload_1:
+	  case op_lload_2:
+	  case op_lload_3:
+	  case op_fload_0:
+	  case op_fload_1:
+	  case op_fload_2:
+	  case op_fload_3:
+	  case op_dload_0:
+	  case op_dload_1:
+	  case op_dload_2:
+	  case op_dload_3:
+	  case op_aload_0:
+	  case op_aload_1:
+	  case op_aload_2:
+	  case op_aload_3:
+	  case op_iaload:
+	  case op_laload:
+	  case op_faload:
+	  case op_daload:
+	  case op_aaload:
+	  case op_baload:
+	  case op_caload:
+	  case op_saload:
+	  case op_istore_0:
+	  case op_istore_1:
+	  case op_istore_2:
+	  case op_istore_3:
+	  case op_lstore_0:
+	  case op_lstore_1:
+	  case op_lstore_2:
+	  case op_lstore_3:
+	  case op_fstore_0:
+	  case op_fstore_1:
+	  case op_fstore_2:
+	  case op_fstore_3:
+	  case op_dstore_0:
+	  case op_dstore_1:
+	  case op_dstore_2:
+	  case op_dstore_3:
+	  case op_astore_0:
+	  case op_astore_1:
+	  case op_astore_2:
+	  case op_astore_3:
+	  case op_iastore:
+	  case op_lastore:
+	  case op_fastore:
+	  case op_dastore:
+	  case op_aastore:
+	  case op_bastore:
+	  case op_castore:
+	  case op_sastore:
+	  case op_pop:
+	  case op_pop2:
+	  case op_dup:
+	  case op_dup_x1:
+	  case op_dup_x2:
+	  case op_dup2:
+	  case op_dup2_x1:
+	  case op_dup2_x2:
+	  case op_swap:
+	  case op_iadd:
+	  case op_isub:
+	  case op_imul:
+	  case op_idiv:
+	  case op_irem:
+	  case op_ishl:
+	  case op_ishr:
+	  case op_iushr:
+	  case op_iand:
+	  case op_ior:
+	  case op_ixor:
+	  case op_ladd:
+	  case op_lsub:
+	  case op_lmul:
+	  case op_ldiv:
+	  case op_lrem:
+	  case op_lshl:
+	  case op_lshr:
+	  case op_lushr:
+	  case op_land:
+	  case op_lor:
+	  case op_lxor:
+	  case op_fadd:
+	  case op_fsub:
+	  case op_fmul:
+	  case op_fdiv:
+	  case op_frem:
+	  case op_dadd:
+	  case op_dsub:
+	  case op_dmul:
+	  case op_ddiv:
+	  case op_drem:
+	  case op_ineg:
+	  case op_i2b:
+	  case op_i2c:
+	  case op_i2s:
+	  case op_lneg:
+	  case op_fneg:
+	  case op_dneg:
+	  case op_i2l:
+	  case op_i2f:
+	  case op_i2d:
+	  case op_l2i:
+	  case op_l2f:
+	  case op_l2d:
+	  case op_f2i:
+	  case op_f2l:
+	  case op_f2d:
+	  case op_d2i:
+	  case op_d2l:
+	  case op_d2f:
+	  case op_lcmp:
+	  case op_fcmpl:
+	  case op_fcmpg:
+	  case op_dcmpl:
+	  case op_dcmpg:
+	  case op_monitorenter:
+	  case op_monitorexit:
+	  case op_ireturn:
+	  case op_lreturn:
+	  case op_freturn:
+	  case op_dreturn:
+	  case op_areturn:
+	  case op_return:
+	  case op_athrow:
+	  case op_arraylength:
+	    break;
+
+	  case op_bipush:
+	  case op_ldc:
+	  case op_iload:
+	  case op_lload:
+	  case op_fload:
+	  case op_dload:
+	  case op_aload:
+	  case op_istore:
+	  case op_lstore:
+	  case op_fstore:
+	  case op_dstore:
+	  case op_astore:
+	  case op_ret:
+	  case op_newarray:
+	    get_byte ();
+	    break;
+
+	  case op_iinc:
+	  case op_sipush:
+	  case op_ldc_w:
+	  case op_ldc2_w:
+	  case op_getstatic:
+	  case op_getfield:
+	  case op_putfield:
+	  case op_putstatic:
+	  case op_new:
+	  case op_anewarray:
+	  case op_instanceof:
+	  case op_checkcast:
+	  case op_invokespecial:
+	  case op_invokestatic:
+	  case op_invokevirtual:
+	    get_short ();
+	    break;
+
+	  case op_multianewarray:
+	    get_short ();
+	    get_byte ();
+	    break;
+
+	  case op_jsr:
+	  case op_ifeq:
+	  case op_ifne:
+	  case op_iflt:
+	  case op_ifge:
+	  case op_ifgt:
+	  case op_ifle:
+	  case op_if_icmpeq:
+	  case op_if_icmpne:
+	  case op_if_icmplt:
+	  case op_if_icmpge:
+	  case op_if_icmpgt:
+	  case op_if_icmple:
+	  case op_if_acmpeq:
+	  case op_if_acmpne:
+	  case op_ifnull:
+	  case op_ifnonnull:
+	  case op_goto:
+	    note_branch_target (compute_jump (get_short ()));
+	    break;
+
+	  case op_tableswitch:
+	    {
+	      skip_padding ();
+	      note_branch_target (compute_jump (get_int ()));
+	      jint low = get_int ();
+	      jint hi = get_int ();
+	      if (low > hi)
+		verify_fail ("invalid tableswitch", start_PC);
+	      for (int i = low; i <= hi; ++i)
+		note_branch_target (compute_jump (get_int ()));
+	    }
+	    break;
+
+	  case op_lookupswitch:
+	    {
+	      skip_padding ();
+	      note_branch_target (compute_jump (get_int ()));
+	      int npairs = get_int ();
+	      if (npairs < 0)
+		verify_fail ("too few pairs in lookupswitch", start_PC);
+	      while (npairs-- > 0)
+		{
+		  get_int ();
+		  note_branch_target (compute_jump (get_int ()));
+		}
+	    }
+	    break;
+
+	  case op_invokeinterface:
+	    get_short ();
+	    get_byte ();
+	    get_byte ();
+	    break;
+
+	  case op_wide:
+	    {
+	      opcode = (java_opcode) get_byte ();
+	      get_short ();
+	      if (opcode == op_iinc)
+		get_short ();
+	    }
+	    break;
+
+	  case op_jsr_w:
+	  case op_goto_w:
+	    note_branch_target (compute_jump (get_int ()));
+	    break;
+
+	  // These are unused here, but we call them out explicitly
+	  // so that -Wswitch-enum doesn't complain.
+	  case op_putfield_1:
+	  case op_putfield_2:
+	  case op_putfield_4:
+	  case op_putfield_8:
+	  case op_putfield_a:
+	  case op_putstatic_1:
+	  case op_putstatic_2:
+	  case op_putstatic_4:
+	  case op_putstatic_8:
+	  case op_putstatic_a:
+	  case op_getfield_1:
+	  case op_getfield_2s:
+	  case op_getfield_2u:
+	  case op_getfield_4:
+	  case op_getfield_8:
+	  case op_getfield_a:
+	  case op_getstatic_1:
+	  case op_getstatic_2s:
+	  case op_getstatic_2u:
+	  case op_getstatic_4:
+	  case op_getstatic_8:
+	  case op_getstatic_a:
+	  case op_breakpoint:
+	  default:
+	    verify_fail ("unrecognized instruction in branch_prepass",
+			 start_PC);
+	  }
+
+	// See if any previous branch tried to branch to the middle of
+	// this instruction.
+	for (int pc = start_PC + 1; pc < PC; ++pc)
+	  {
+	    if ((flags[pc] & FLAG_BRANCH_TARGET))
+	      verify_fail ("branch to middle of instruction", pc);
+	  }
+      }
+
+    // Verify exception handlers.
+    for (int i = 0; i < current_method->exc_count; ++i)
+      {
+	if (! (flags[exception[i].handler_pc.i] & FLAG_INSN_START))
+	  verify_fail ("exception handler not at instruction start",
+		       exception[i].handler_pc.i);
+	if (! (flags[exception[i].start_pc.i] & FLAG_INSN_START))
+	  verify_fail ("exception start not at instruction start",
+		       exception[i].start_pc.i);
+	if (exception[i].end_pc.i != current_method->code_length
+	    && ! (flags[exception[i].end_pc.i] & FLAG_INSN_START))
+	  verify_fail ("exception end not at instruction start",
+		       exception[i].end_pc.i);
+
+	flags[exception[i].handler_pc.i] |= FLAG_BRANCH_TARGET;
+      }
+  }
+
+  void check_pool_index (int index)
+  {
+    if (index < 0 || index >= current_class->constants.size)
+      verify_fail ("constant pool index out of range", start_PC);
+  }
+
+  type check_class_constant (int index)
+  {
+    check_pool_index (index);
+    _Jv_Constants *pool = &current_class->constants;
+    if (pool->tags[index] == JV_CONSTANT_ResolvedClass)
+      return type (pool->data[index].clazz, this);
+    else if (pool->tags[index] == JV_CONSTANT_Class)
+      return type (pool->data[index].utf8, this);
+    verify_fail ("expected class constant", start_PC);
+  }
+
+  type check_constant (int index)
+  {
+    check_pool_index (index);
+    _Jv_Constants *pool = &current_class->constants;
+    int tag = pool->tags[index];
+    if (tag == JV_CONSTANT_ResolvedString || tag == JV_CONSTANT_String)
+      return type (&java::lang::String::class$, this);
+    else if (tag == JV_CONSTANT_Integer)
+      return type (int_type);
+    else if (tag == JV_CONSTANT_Float)
+      return type (float_type);
+    else if (current_method->is_15
+	     && (tag == JV_CONSTANT_ResolvedClass || tag == JV_CONSTANT_Class))
+      return type (&java::lang::Class::class$, this);
+    verify_fail ("String, int, or float constant expected", start_PC);
+  }
+
+  type check_wide_constant (int index)
+  {
+    check_pool_index (index);
+    _Jv_Constants *pool = &current_class->constants;
+    if (pool->tags[index] == JV_CONSTANT_Long)
+      return type (long_type);
+    else if (pool->tags[index] == JV_CONSTANT_Double)
+      return type (double_type);
+    verify_fail ("long or double constant expected", start_PC);
+  }
+
+  // Helper for both field and method.  These are laid out the same in
+  // the constant pool.
+  type handle_field_or_method (int index, int expected,
+			       _Jv_Utf8Const **name,
+			       _Jv_Utf8Const **fmtype)
+  {
+    check_pool_index (index);
+    _Jv_Constants *pool = &current_class->constants;
+    if (pool->tags[index] != expected)
+      verify_fail ("didn't see expected constant", start_PC);
+    // Once we know we have a Fieldref or Methodref we assume that it
+    // is correctly laid out in the constant pool.  I think the code
+    // in defineclass.cc guarantees this.
+    _Jv_ushort class_index, name_and_type_index;
+    _Jv_loadIndexes (&pool->data[index],
+		     class_index,
+		     name_and_type_index);
+    _Jv_ushort name_index, desc_index;
+    _Jv_loadIndexes (&pool->data[name_and_type_index],
+		     name_index, desc_index);
+
+    *name = pool->data[name_index].utf8;
+    *fmtype = pool->data[desc_index].utf8;
+
+    return check_class_constant (class_index);
+  }
+
+  // Return field's type, compute class' type if requested.
+  // If PUTFIELD is true, use the special 'putfield' semantics.
+  type check_field_constant (int index, type *class_type = NULL,
+			     bool putfield = false)
+  {
+    _Jv_Utf8Const *name, *field_type;
+    type ct = handle_field_or_method (index,
+				      JV_CONSTANT_Fieldref,
+				      &name, &field_type);
+    if (class_type)
+      *class_type = ct;
+    type result;
+    if (field_type->first() == '[' || field_type->first() == 'L')
+      result = type (field_type, this);
+    else
+      result = get_type_val_for_signature (field_type->first());
+
+    // We have an obscure special case here: we can use `putfield' on
+    // a field declared in this class, even if `this' has not yet been
+    // initialized.
+    if (putfield
+	&& ! current_state->this_type.isinitialized ()
+	&& current_state->this_type.pc == type::SELF
+	&& current_state->this_type.equals (ct, this)
+	// We don't look at the signature, figuring that if it is
+	// wrong we will fail during linking.  FIXME?
+	&& _Jv_Linker::has_field_p (current_class, name))
+      // Note that we don't actually know whether we're going to match
+      // against 'this' or some other object of the same type.  So,
+      // here we set things up so that it doesn't matter.  This relies
+      // on knowing what our caller is up to.
+      class_type->set_uninitialized (type::EITHER, this);
+
+    return result;
+  }
+
+  type check_method_constant (int index, bool is_interface,
+			      _Jv_Utf8Const **method_name,
+			      _Jv_Utf8Const **method_signature)
+  {
+    return handle_field_or_method (index,
+				   (is_interface
+				    ? JV_CONSTANT_InterfaceMethodref
+				    : JV_CONSTANT_Methodref),
+				   method_name, method_signature);
+  }
+
+  type get_one_type (char *&p)
+  {
+    char *start = p;
+
+    int arraycount = 0;
+    while (*p == '[')
+      {
+	++arraycount;
+	++p;
+      }
+
+    char v = *p++;
+
+    if (v == 'L')
+      {
+	while (*p != ';')
+	  ++p;
+	++p;
+	_Jv_Utf8Const *name = make_utf8_const (start, p - start);
+	return type (name, this);
+      }
+
+    // Casting to jchar here is ok since we are looking at an ASCII
+    // character.
+    type_val rt = get_type_val_for_signature (jchar (v));
+
+    if (arraycount == 0)
+      {
+	// Callers of this function eventually push their arguments on
+	// the stack.  So, promote them here.
+	return type (rt).promote ();
+      }
+
+    jclass k = construct_primitive_array_type (rt);
+    while (--arraycount > 0)
+      k = _Jv_GetArrayClass (k, NULL);
+    return type (k, this);
+  }
+
+  void compute_argument_types (_Jv_Utf8Const *signature,
+			       type *types)
+  {
+    char *p = signature->chars();
+
+    // Skip `('.
+    ++p;
+
+    int i = 0;
+    while (*p != ')')
+      types[i++] = get_one_type (p);
+  }
+
+  type compute_return_type (_Jv_Utf8Const *signature)
+  {
+    char *p = signature->chars();
+    while (*p != ')')
+      ++p;
+    ++p;
+    return get_one_type (p);
+  }
+
+  void check_return_type (type onstack)
+  {
+    type rt = compute_return_type (current_method->self->signature);
+    if (! rt.compatible (onstack, this))
+      verify_fail ("incompatible return type");
+  }
+
+  // Initialize the stack for the new method.  Returns true if this
+  // method is an instance initializer.
+  bool initialize_stack ()
+  {
+    int var = 0;
+    bool is_init = _Jv_equalUtf8Consts (current_method->self->name,
+					gcj::init_name);
+    bool is_clinit = _Jv_equalUtf8Consts (current_method->self->name,
+					  gcj::clinit_name);
+
+    using namespace java::lang::reflect;
+    if (! Modifier::isStatic (current_method->self->accflags))
+      {
+	type kurr (current_class, this);
+	if (is_init)
+	  {
+	    kurr.set_uninitialized (type::SELF, this);
+	    is_init = true;
+	  }
+	else if (is_clinit)
+	  verify_fail ("<clinit> method must be static");
+	set_variable (0, kurr);
+	current_state->set_this_type (kurr);
+	++var;
+      }
+    else
+      {
+	if (is_init)
+	  verify_fail ("<init> method must be non-static");
+      }
+
+    // We have to handle wide arguments specially here.
+    int arg_count = _Jv_count_arguments (current_method->self->signature);
+    type arg_types[arg_count];
+    compute_argument_types (current_method->self->signature, arg_types);
+    for (int i = 0; i < arg_count; ++i)
+      {
+	set_variable (var, arg_types[i]);
+	++var;
+	if (arg_types[i].iswide ())
+	  ++var;
+      }
+
+    return is_init;
+  }
+
+  void verify_instructions_0 ()
+  {
+    current_state = new state (current_method->max_stack,
+			       current_method->max_locals);
+
+    PC = 0;
+    start_PC = 0;
+
+    // True if we are verifying an instance initializer.
+    bool this_is_init = initialize_stack ();
+
+    states = (linked<state> **) _Jv_Malloc (sizeof (linked<state> *)
+					    * current_method->code_length);
+    for (int i = 0; i < current_method->code_length; ++i)
+      states[i] = NULL;
+
+    next_verify_state = NULL;
+
+    while (true)
+      {
+	// If the PC was invalidated, get a new one from the work list.
+	if (PC == state::NO_NEXT)
+	  {
+	    state *new_state = pop_jump ();
+	    // If it is null, we're done.
+	    if (new_state == NULL)
+	      break;
+
+	    PC = new_state->get_pc ();
+	    debug_print ("== State pop from pending list\n");
+	    // Set up the current state.
+	    current_state->copy (new_state, current_method->max_stack,
+				 current_method->max_locals);
+	  }
+	else
+	  {
+	    // We only have to do this checking in the situation where
+	    // control flow falls through from the previous
+	    // instruction.  Otherwise merging is done at the time we
+	    // push the branch.  Note that we'll catch the
+	    // off-the-end problem just below.
+	    if (PC < current_method->code_length && states[PC] != NULL)
+	      {
+		// We've already visited this instruction.  So merge
+		// the states together.  It is simplest, but not most
+		// efficient, to just always invalidate the PC here.
+		merge_into (PC, current_state);
+		invalidate_pc ();
+		continue;
+	      }
+	  }
+
+	// Control can't fall off the end of the bytecode.  We need to
+	// check this in both cases, not just the fall-through case,
+	// because we don't check to see whether a `jsr' appears at
+	// the end of the bytecode until we process a `ret'.
+	if (PC >= current_method->code_length)
+	  verify_fail ("fell off end");
+
+	// We only have to keep saved state at branch targets.  If
+	// we're at a branch target and the state here hasn't been set
+	// yet, we set it now.  You might notice that `ret' targets
+	// won't necessarily have FLAG_BRANCH_TARGET set.  This
+	// doesn't matter, since those states will be filled in by
+	// merge_into.
+	if (states[PC] == NULL && (flags[PC] & FLAG_BRANCH_TARGET))
+	  add_new_state (PC, current_state);
+
+	// Set this before handling exceptions so that debug output is
+	// sane.
+	start_PC = PC;
+
+	// Update states for all active exception handlers.  Ordinarily
+	// there are not many exception handlers.  So we simply run
+	// through them all.
+	for (int i = 0; i < current_method->exc_count; ++i)
+	  {
+	    if (PC >= exception[i].start_pc.i && PC < exception[i].end_pc.i)
+	      {
+		type handler (&java::lang::Throwable::class$, this);
+		if (exception[i].handler_type.i != 0)
+		  handler = check_class_constant (exception[i].handler_type.i);
+		push_exception_jump (handler, exception[i].handler_pc.i);
+	      }
+	  }
+
+	current_state->print ("   ", PC, current_method->max_stack,
+			      current_method->max_locals);
+	java_opcode opcode = (java_opcode) bytecode[PC++];
+	switch (opcode)
+	  {
+	  case op_nop:
+	    break;
+
+	  case op_aconst_null:
+	    push_type (null_type);
+	    break;
+
+	  case op_iconst_m1:
+	  case op_iconst_0:
+	  case op_iconst_1:
+	  case op_iconst_2:
+	  case op_iconst_3:
+	  case op_iconst_4:
+	  case op_iconst_5:
+	    push_type (int_type);
+	    break;
+
+	  case op_lconst_0:
+	  case op_lconst_1:
+	    push_type (long_type);
+	    break;
+
+	  case op_fconst_0:
+	  case op_fconst_1:
+	  case op_fconst_2:
+	    push_type (float_type);
+	    break;
+
+	  case op_dconst_0:
+	  case op_dconst_1:
+	    push_type (double_type);
+	    break;
+
+	  case op_bipush:
+	    get_byte ();
+	    push_type (int_type);
+	    break;
+
+	  case op_sipush:
+	    get_short ();
+	    push_type (int_type);
+	    break;
+
+	  case op_ldc:
+	    push_type (check_constant (get_byte ()));
+	    break;
+	  case op_ldc_w:
+	    push_type (check_constant (get_ushort ()));
+	    break;
+	  case op_ldc2_w:
+	    push_type (check_wide_constant (get_ushort ()));
+	    break;
+
+	  case op_iload:
+	    push_type (get_variable (get_byte (), int_type));
+	    break;
+	  case op_lload:
+	    push_type (get_variable (get_byte (), long_type));
+	    break;
+	  case op_fload:
+	    push_type (get_variable (get_byte (), float_type));
+	    break;
+	  case op_dload:
+	    push_type (get_variable (get_byte (), double_type));
+	    break;
+	  case op_aload:
+	    push_type (get_variable (get_byte (), reference_type));
+	    break;
+
+	  case op_iload_0:
+	  case op_iload_1:
+	  case op_iload_2:
+	  case op_iload_3:
+	    push_type (get_variable (opcode - op_iload_0, int_type));
+	    break;
+	  case op_lload_0:
+	  case op_lload_1:
+	  case op_lload_2:
+	  case op_lload_3:
+	    push_type (get_variable (opcode - op_lload_0, long_type));
+	    break;
+	  case op_fload_0:
+	  case op_fload_1:
+	  case op_fload_2:
+	  case op_fload_3:
+	    push_type (get_variable (opcode - op_fload_0, float_type));
+	    break;
+	  case op_dload_0:
+	  case op_dload_1:
+	  case op_dload_2:
+	  case op_dload_3:
+	    push_type (get_variable (opcode - op_dload_0, double_type));
+	    break;
+	  case op_aload_0:
+	  case op_aload_1:
+	  case op_aload_2:
+	  case op_aload_3:
+	    push_type (get_variable (opcode - op_aload_0, reference_type));
+	    break;
+	  case op_iaload:
+	    pop_type (int_type);
+	    push_type (require_array_type (pop_init_ref (reference_type),
+					   int_type));
+	    break;
+	  case op_laload:
+	    pop_type (int_type);
+	    push_type (require_array_type (pop_init_ref (reference_type),
+					   long_type));
+	    break;
+	  case op_faload:
+	    pop_type (int_type);
+	    push_type (require_array_type (pop_init_ref (reference_type),
+					   float_type));
+	    break;
+	  case op_daload:
+	    pop_type (int_type);
+	    push_type (require_array_type (pop_init_ref (reference_type),
+					   double_type));
+	    break;
+	  case op_aaload:
+	    pop_type (int_type);
+	    push_type (require_array_type (pop_init_ref (reference_type),
+					   reference_type));
+	    break;
+	  case op_baload:
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), byte_type);
+	    push_type (int_type);
+	    break;
+	  case op_caload:
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), char_type);
+	    push_type (int_type);
+	    break;
+	  case op_saload:
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), short_type);
+	    push_type (int_type);
+	    break;
+	  case op_istore:
+	    set_variable (get_byte (), pop_type (int_type));
+	    break;
+	  case op_lstore:
+	    set_variable (get_byte (), pop_type (long_type));
+	    break;
+	  case op_fstore:
+	    set_variable (get_byte (), pop_type (float_type));
+	    break;
+	  case op_dstore:
+	    set_variable (get_byte (), pop_type (double_type));
+	    break;
+	  case op_astore:
+	    set_variable (get_byte (), pop_ref_or_return ());
+	    break;
+	  case op_istore_0:
+	  case op_istore_1:
+	  case op_istore_2:
+	  case op_istore_3:
+	    set_variable (opcode - op_istore_0, pop_type (int_type));
+	    break;
+	  case op_lstore_0:
+	  case op_lstore_1:
+	  case op_lstore_2:
+	  case op_lstore_3:
+	    set_variable (opcode - op_lstore_0, pop_type (long_type));
+	    break;
+	  case op_fstore_0:
+	  case op_fstore_1:
+	  case op_fstore_2:
+	  case op_fstore_3:
+	    set_variable (opcode - op_fstore_0, pop_type (float_type));
+	    break;
+	  case op_dstore_0:
+	  case op_dstore_1:
+	  case op_dstore_2:
+	  case op_dstore_3:
+	    set_variable (opcode - op_dstore_0, pop_type (double_type));
+	    break;
+	  case op_astore_0:
+	  case op_astore_1:
+	  case op_astore_2:
+	  case op_astore_3:
+	    set_variable (opcode - op_astore_0, pop_ref_or_return ());
+	    break;
+	  case op_iastore:
+	    pop_type (int_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), int_type);
+	    break;
+	  case op_lastore:
+	    pop_type (long_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), long_type);
+	    break;
+	  case op_fastore:
+	    pop_type (float_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), float_type);
+	    break;
+	  case op_dastore:
+	    pop_type (double_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), double_type);
+	    break;
+	  case op_aastore:
+	    pop_type (reference_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), reference_type);
+	    break;
+	  case op_bastore:
+	    pop_type (int_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), byte_type);
+	    break;
+	  case op_castore:
+	    pop_type (int_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), char_type);
+	    break;
+	  case op_sastore:
+	    pop_type (int_type);
+	    pop_type (int_type);
+	    require_array_type (pop_init_ref (reference_type), short_type);
+	    break;
+	  case op_pop:
+	    pop32 ();
+	    break;
+	  case op_pop2:
+	    {
+	      type t = pop_raw ();
+	      if (! t.iswide ())
+		pop32 ();
+	    }
+	    break;
+	  case op_dup:
+	    {
+	      type t = pop32 ();
+	      push_type (t);
+	      push_type (t);
+	    }
+	    break;
+	  case op_dup_x1:
+	    {
+	      type t1 = pop32 ();
+	      type t2 = pop32 ();
+	      push_type (t1);
+	      push_type (t2);
+	      push_type (t1);
+	    }
+	    break;
+	  case op_dup_x2:
+	    {
+	      type t1 = pop32 ();
+	      type t2 = pop_raw ();
+	      if (! t2.iswide ())
+		{
+		  type t3 = pop32 ();
+		  push_type (t1);
+		  push_type (t3);
+		}
+	      else
+		push_type (t1);
+	      push_type (t2);
+	      push_type (t1);
+	    }
+	    break;
+	  case op_dup2:
+	    {
+	      type t = pop_raw ();
+	      if (! t.iswide ())
+		{
+		  type t2 = pop32 ();
+		  push_type (t2);
+		  push_type (t);
+		  push_type (t2);
+		}
+	      else
+		push_type (t);
+	      push_type (t);
+	    }
+	    break;
+	  case op_dup2_x1:
+	    {
+	      type t1 = pop_raw ();
+	      type t2 = pop32 ();
+	      if (! t1.iswide ())
+		{
+		  type t3 = pop32 ();
+		  push_type (t2);
+		  push_type (t1);
+		  push_type (t3);
+		}
+	      else
+		push_type (t1);
+	      push_type (t2);
+	      push_type (t1);
+	    }
+	    break;
+	  case op_dup2_x2:
+	    {
+	      type t1 = pop_raw ();
+	      if (t1.iswide ())
+		{
+		  type t2 = pop_raw ();
+		  if (t2.iswide ())
+		    {
+		      push_type (t1);
+		      push_type (t2);
+		    }
+		  else
+		    {
+		      type t3 = pop32 ();
+		      push_type (t1);
+		      push_type (t3);
+		      push_type (t2);
+		    }
+		  push_type (t1);
+		}
+	      else
+		{
+		  type t2 = pop32 ();
+		  type t3 = pop_raw ();
+		  if (t3.iswide ())
+		    {
+		      push_type (t2);
+		      push_type (t1);
+		    }
+		  else
+		    {
+		      type t4 = pop32 ();
+		      push_type (t2);
+		      push_type (t1);
+		      push_type (t4);
+		    }
+		  push_type (t3);
+		  push_type (t2);
+		  push_type (t1);
+		}
+	    }
+	    break;
+	  case op_swap:
+	    {
+	      type t1 = pop32 ();
+	      type t2 = pop32 ();
+	      push_type (t1);
+	      push_type (t2);
+	    }
+	    break;
+	  case op_iadd:
+	  case op_isub:
+	  case op_imul:
+	  case op_idiv:
+	  case op_irem:
+	  case op_ishl:
+	  case op_ishr:
+	  case op_iushr:
+	  case op_iand:
+	  case op_ior:
+	  case op_ixor:
+	    pop_type (int_type);
+	    push_type (pop_type (int_type));
+	    break;
+	  case op_ladd:
+	  case op_lsub:
+	  case op_lmul:
+	  case op_ldiv:
+	  case op_lrem:
+	  case op_land:
+	  case op_lor:
+	  case op_lxor:
+	    pop_type (long_type);
+	    push_type (pop_type (long_type));
+	    break;
+	  case op_lshl:
+	  case op_lshr:
+	  case op_lushr:
+	    pop_type (int_type);
+	    push_type (pop_type (long_type));
+	    break;
+	  case op_fadd:
+	  case op_fsub:
+	  case op_fmul:
+	  case op_fdiv:
+	  case op_frem:
+	    pop_type (float_type);
+	    push_type (pop_type (float_type));
+	    break;
+	  case op_dadd:
+	  case op_dsub:
+	  case op_dmul:
+	  case op_ddiv:
+	  case op_drem:
+	    pop_type (double_type);
+	    push_type (pop_type (double_type));
+	    break;
+	  case op_ineg:
+	  case op_i2b:
+	  case op_i2c:
+	  case op_i2s:
+	    push_type (pop_type (int_type));
+	    break;
+	  case op_lneg:
+	    push_type (pop_type (long_type));
+	    break;
+	  case op_fneg:
+	    push_type (pop_type (float_type));
+	    break;
+	  case op_dneg:
+	    push_type (pop_type (double_type));
+	    break;
+	  case op_iinc:
+	    get_variable (get_byte (), int_type);
+	    get_byte ();
+	    break;
+	  case op_i2l:
+	    pop_type (int_type);
+	    push_type (long_type);
+	    break;
+	  case op_i2f:
+	    pop_type (int_type);
+	    push_type (float_type);
+	    break;
+	  case op_i2d:
+	    pop_type (int_type);
+	    push_type (double_type);
+	    break;
+	  case op_l2i:
+	    pop_type (long_type);
+	    push_type (int_type);
+	    break;
+	  case op_l2f:
+	    pop_type (long_type);
+	    push_type (float_type);
+	    break;
+	  case op_l2d:
+	    pop_type (long_type);
+	    push_type (double_type);
+	    break;
+	  case op_f2i:
+	    pop_type (float_type);
+	    push_type (int_type);
+	    break;
+	  case op_f2l:
+	    pop_type (float_type);
+	    push_type (long_type);
+	    break;
+	  case op_f2d:
+	    pop_type (float_type);
+	    push_type (double_type);
+	    break;
+	  case op_d2i:
+	    pop_type (double_type);
+	    push_type (int_type);
+	    break;
+	  case op_d2l:
+	    pop_type (double_type);
+	    push_type (long_type);
+	    break;
+	  case op_d2f:
+	    pop_type (double_type);
+	    push_type (float_type);
+	    break;
+	  case op_lcmp:
+	    pop_type (long_type);
+	    pop_type (long_type);
+	    push_type (int_type);
+	    break;
+	  case op_fcmpl:
+	  case op_fcmpg:
+	    pop_type (float_type);
+	    pop_type (float_type);
+	    push_type (int_type);
+	    break;
+	  case op_dcmpl:
+	  case op_dcmpg:
+	    pop_type (double_type);
+	    pop_type (double_type);
+	    push_type (int_type);
+	    break;
+	  case op_ifeq:
+	  case op_ifne:
+	  case op_iflt:
+	  case op_ifge:
+	  case op_ifgt:
+	  case op_ifle:
+	    pop_type (int_type);
+	    push_jump (get_short ());
+	    break;
+	  case op_if_icmpeq:
+	  case op_if_icmpne:
+	  case op_if_icmplt:
+	  case op_if_icmpge:
+	  case op_if_icmpgt:
+	  case op_if_icmple:
+	    pop_type (int_type);
+	    pop_type (int_type);
+	    push_jump (get_short ());
+	    break;
+	  case op_if_acmpeq:
+	  case op_if_acmpne:
+	    pop_type (reference_type);
+	    pop_type (reference_type);
+	    push_jump (get_short ());
+	    break;
+	  case op_goto:
+	    push_jump (get_short ());
+	    invalidate_pc ();
+	    break;
+	  case op_jsr:
+	    handle_jsr_insn (get_short ());
+	    break;
+	  case op_ret:
+	    handle_ret_insn (get_byte ());
+	    break;
+	  case op_tableswitch:
+	    {
+	      pop_type (int_type);
+	      skip_padding ();
+	      push_jump (get_int ());
+	      jint low = get_int ();
+	      jint high = get_int ();
+	      // Already checked LOW -vs- HIGH.
+	      for (int i = low; i <= high; ++i)
+		push_jump (get_int ());
+	      invalidate_pc ();
+	    }
+	    break;
+
+	  case op_lookupswitch:
+	    {
+	      pop_type (int_type);
+	      skip_padding ();
+	      push_jump (get_int ());
+	      jint npairs = get_int ();
+	      // Already checked NPAIRS >= 0.
+	      jint lastkey = 0;
+	      for (int i = 0; i < npairs; ++i)
+		{
+		  jint key = get_int ();
+		  if (i > 0 && key <= lastkey)
+		    verify_fail ("lookupswitch pairs unsorted", start_PC);
+		  lastkey = key;
+		  push_jump (get_int ());
+		}
+	      invalidate_pc ();
+	    }
+	    break;
+	  case op_ireturn:
+	    check_return_type (pop_type (int_type));
+	    invalidate_pc ();
+	    break;
+	  case op_lreturn:
+	    check_return_type (pop_type (long_type));
+	    invalidate_pc ();
+	    break;
+	  case op_freturn:
+	    check_return_type (pop_type (float_type));
+	    invalidate_pc ();
+	    break;
+	  case op_dreturn:
+	    check_return_type (pop_type (double_type));
+	    invalidate_pc ();
+	    break;
+	  case op_areturn:
+	    check_return_type (pop_init_ref (reference_type));
+	    invalidate_pc ();
+	    break;
+	  case op_return:
+	    // We only need to check this when the return type is
+	    // void, because all instance initializers return void.
+	    if (this_is_init)
+	      current_state->check_this_initialized (this);
+	    check_return_type (void_type);
+	    invalidate_pc ();
+	    break;
+	  case op_getstatic:
+	    push_type (check_field_constant (get_ushort ()));
+	    break;
+	  case op_putstatic:
+	    pop_type (check_field_constant (get_ushort ()));
+	    break;
+	  case op_getfield:
+	    {
+	      type klass;
+	      type field = check_field_constant (get_ushort (), &klass);
+	      pop_type (klass);
+	      push_type (field);
+	    }
+	    break;
+	  case op_putfield:
+	    {
+	      type klass;
+	      type field = check_field_constant (get_ushort (), &klass, true);
+	      pop_type (field);
+	      pop_type (klass);
+	    }
+	    break;
+
+	  case op_invokevirtual:
+	  case op_invokespecial:
+	  case op_invokestatic:
+	  case op_invokeinterface:
+	    {
+	      _Jv_Utf8Const *method_name, *method_signature;
+	      type class_type
+		= check_method_constant (get_ushort (),
+					 opcode == op_invokeinterface,
+					 &method_name,
+					 &method_signature);
+	      // NARGS is only used when we're processing
+	      // invokeinterface.  It is simplest for us to compute it
+	      // here and then verify it later.
+	      int nargs = 0;
+	      if (opcode == op_invokeinterface)
+		{
+		  nargs = get_byte ();
+		  if (get_byte () != 0)
+		    verify_fail ("invokeinterface dummy byte is wrong");
+		}
+
+	      bool is_init = false;
+	      if (_Jv_equalUtf8Consts (method_name, gcj::init_name))
+		{
+		  is_init = true;
+		  if (opcode != op_invokespecial)
+		    verify_fail ("can't invoke <init>");
+		}
+	      else if (method_name->first() == '<')
+		verify_fail ("can't invoke method starting with `<'");
+
+	      // Pop arguments and check types.
+	      int arg_count = _Jv_count_arguments (method_signature);
+	      type arg_types[arg_count];
+	      compute_argument_types (method_signature, arg_types);
+	      for (int i = arg_count - 1; i >= 0; --i)
+		{
+		  // This is only used for verifying the byte for
+		  // invokeinterface.
+		  nargs -= arg_types[i].depth ();
+		  pop_init_ref (arg_types[i]);
+		}
+
+	      if (opcode == op_invokeinterface
+		  && nargs != 1)
+		verify_fail ("wrong argument count for invokeinterface");
+
+	      if (opcode != op_invokestatic)
+		{
+		  type t = class_type;
+		  if (is_init)
+		    {
+		      // In this case the PC doesn't matter.
+		      t.set_uninitialized (type::UNINIT, this);
+		      // FIXME: check to make sure that the <init>
+		      // call is to the right class.
+		      // It must either be super or an exact class
+		      // match.
+		    }
+		  type raw = pop_raw ();
+		  if (! t.compatible (raw, this))
+		    verify_fail ("incompatible type on stack");
+
+		  if (is_init)
+		    current_state->set_initialized (raw.get_pc (),
+						    current_method->max_locals);
+		}
+
+	      type rt = compute_return_type (method_signature);
+	      if (! rt.isvoid ())
+		push_type (rt);
+	    }
+	    break;
+
+	  case op_new:
+	    {
+	      type t = check_class_constant (get_ushort ());
+	      if (t.isarray ())
+		verify_fail ("type is array");
+	      t.set_uninitialized (start_PC, this);
+	      push_type (t);
+	    }
+	    break;
+
+	  case op_newarray:
+	    {
+	      int atype = get_byte ();
+	      // We intentionally have chosen constants to make this
+	      // valid.
+	      if (atype < boolean_type || atype > long_type)
+		verify_fail ("type not primitive", start_PC);
+	      pop_type (int_type);
+	      type t (construct_primitive_array_type (type_val (atype)), this);
+	      push_type (t);
+	    }
+	    break;
+	  case op_anewarray:
+	    pop_type (int_type);
+	    push_type (check_class_constant (get_ushort ()).to_array (this));
+	    break;
+	  case op_arraylength:
+	    {
+	      type t = pop_init_ref (reference_type);
+	      if (! t.isarray () && ! t.isnull ())
+		verify_fail ("array type expected");
+	      push_type (int_type);
+	    }
+	    break;
+	  case op_athrow:
+	    pop_type (type (&java::lang::Throwable::class$, this));
+	    invalidate_pc ();
+	    break;
+	  case op_checkcast:
+	    pop_init_ref (reference_type);
+	    push_type (check_class_constant (get_ushort ()));
+	    break;
+	  case op_instanceof:
+	    pop_init_ref (reference_type);
+	    check_class_constant (get_ushort ());
+	    push_type (int_type);
+	    break;
+	  case op_monitorenter:
+	    pop_init_ref (reference_type);
+	    break;
+	  case op_monitorexit:
+	    pop_init_ref (reference_type);
+	    break;
+	  case op_wide:
+	    {
+	      switch (get_byte ())
+		{
+		case op_iload:
+		  push_type (get_variable (get_ushort (), int_type));
+		  break;
+		case op_lload:
+		  push_type (get_variable (get_ushort (), long_type));
+		  break;
+		case op_fload:
+		  push_type (get_variable (get_ushort (), float_type));
+		  break;
+		case op_dload:
+		  push_type (get_variable (get_ushort (), double_type));
+		  break;
+		case op_aload:
+		  push_type (get_variable (get_ushort (), reference_type));
+		  break;
+		case op_istore:
+		  set_variable (get_ushort (), pop_type (int_type));
+		  break;
+		case op_lstore:
+		  set_variable (get_ushort (), pop_type (long_type));
+		  break;
+		case op_fstore:
+		  set_variable (get_ushort (), pop_type (float_type));
+		  break;
+		case op_dstore:
+		  set_variable (get_ushort (), pop_type (double_type));
+		  break;
+		case op_astore:
+		  set_variable (get_ushort (), pop_init_ref (reference_type));
+		  break;
+		case op_ret:
+		  handle_ret_insn (get_short ());
+		  break;
+		case op_iinc:
+		  get_variable (get_ushort (), int_type);
+		  get_short ();
+		  break;
+		default:
+		  verify_fail ("unrecognized wide instruction", start_PC);
+		}
+	    }
+	    break;
+	  case op_multianewarray:
+	    {
+	      type atype = check_class_constant (get_ushort ());
+	      int dim = get_byte ();
+	      if (dim < 1)
+		verify_fail ("too few dimensions to multianewarray", start_PC);
+	      atype.verify_dimensions (dim, this);
+	      for (int i = 0; i < dim; ++i)
+		pop_type (int_type);
+	      push_type (atype);
+	    }
+	    break;
+	  case op_ifnull:
+	  case op_ifnonnull:
+	    pop_type (reference_type);
+	    push_jump (get_short ());
+	    break;
+	  case op_goto_w:
+	    push_jump (get_int ());
+	    invalidate_pc ();
+	    break;
+	  case op_jsr_w:
+	    handle_jsr_insn (get_int ());
+	    break;
+
+	  // These are unused here, but we call them out explicitly
+	  // so that -Wswitch-enum doesn't complain.
+	  case op_putfield_1:
+	  case op_putfield_2:
+	  case op_putfield_4:
+	  case op_putfield_8:
+	  case op_putfield_a:
+	  case op_putstatic_1:
+	  case op_putstatic_2:
+	  case op_putstatic_4:
+	  case op_putstatic_8:
+	  case op_putstatic_a:
+	  case op_getfield_1:
+	  case op_getfield_2s:
+	  case op_getfield_2u:
+	  case op_getfield_4:
+	  case op_getfield_8:
+	  case op_getfield_a:
+	  case op_getstatic_1:
+	  case op_getstatic_2s:
+	  case op_getstatic_2u:
+	  case op_getstatic_4:
+	  case op_getstatic_8:
+	  case op_getstatic_a:
+	  case op_breakpoint:
+	  default:
+	    // Unrecognized opcode.
+	    verify_fail ("unrecognized instruction in verify_instructions_0",
+			 start_PC);
+	  }
+      }
+  }
+
+public:
+
+  void verify_instructions ()
+  {
+    branch_prepass ();
+    verify_instructions_0 ();
+  }
+
+  _Jv_BytecodeVerifier (_Jv_InterpMethod *m)
+  {
+    // We just print the text as utf-8.  This is just for debugging
+    // anyway.
+    debug_print ("--------------------------------\n");
+    debug_print ("-- Verifying method `%s'\n", m->self->name->chars());
+
+    current_method = m;
+    bytecode = m->bytecode ();
+    exception = m->exceptions ();
+    current_class = m->defining_class;
+
+    states = NULL;
+    flags = NULL;
+    utf8_list = NULL;
+    isect_list = NULL;
+  }
+
+  ~_Jv_BytecodeVerifier ()
+  {
+    if (flags)
+      _Jv_Free (flags);
+
+    while (utf8_list != NULL)
+      {
+	linked<_Jv_Utf8Const> *n = utf8_list->next;
+	_Jv_Free (utf8_list);
+	utf8_list = n;
+      }
+
+    while (isect_list != NULL)
+      {
+	ref_intersection *next = isect_list->alloc_next;
+	delete isect_list;
+	isect_list = next;
+      }
+
+    if (states)
+      {
+	for (int i = 0; i < current_method->code_length; ++i)
+	  {
+	    linked<state> *iter = states[i];
+	    while (iter != NULL)
+	      {
+		linked<state> *next = iter->next;
+		delete iter->val;
+		_Jv_Free (iter);
+		iter = next;
+	      }
+	  }
+	_Jv_Free (states);
+      }
+  }
+};
+
+void
+_Jv_VerifyMethod (_Jv_InterpMethod *meth)
+{
+  _Jv_BytecodeVerifier v (meth);
+  v.verify_instructions ();
+}
+
+#endif	/* INTERPRETER */

Added: llvm-gcc-4.2/trunk/libjava/win32-threads.cc
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/win32-threads.cc?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/win32-threads.cc (added)
+++ llvm-gcc-4.2/trunk/libjava/win32-threads.cc Thu Nov  8 16:56:19 2007
@@ -0,0 +1,422 @@
+// win32-threads.cc - interface between libjava and Win32 threads.
+
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2006 Free Software
+   Foundation, Inc.
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+#include <config.h>
+
+// If we're using the Boehm GC, then we need to override some of the
+// thread primitives.  This is fairly gross.
+#ifdef HAVE_BOEHM_GC
+extern "C"
+{
+#include <gc.h>
+// <windows.h> #define's STRICT, which conflicts with Modifier.h
+#undef STRICT
+};
+#endif /* HAVE_BOEHM_GC */
+
+#include <gcj/cni.h>
+#include <jvm.h>
+#include <java/lang/Thread.h>
+#include <java/lang/System.h>
+
+#include <errno.h>
+
+#ifndef ETIMEDOUT
+#define ETIMEDOUT 116
+#endif
+
+// This is used to implement thread startup.
+struct starter
+{
+  _Jv_ThreadStartFunc *method;
+  _Jv_Thread_t *data;
+};
+
+// Controls access to the variable below
+static HANDLE daemon_mutex;
+static HANDLE daemon_cond;
+// Number of non-daemon threads - _Jv_ThreadWait returns when this is 0
+static int non_daemon_count;
+
+// TLS key get Java object representing the thread
+DWORD _Jv_ThreadKey;
+// TLS key to get _Jv_Thread_t* representing the thread
+DWORD _Jv_ThreadDataKey;
+
+//
+// These are the flags that can appear in _Jv_Thread_t.
+//
+
+// Thread started.
+#define FLAG_START   0x01
+// Thread is daemon.
+#define FLAG_DAEMON  0x02
+
+//
+// Condition variables.
+//
+
+// we do lazy creation of Events since CreateEvent() is insanely
+// expensive, and because the rest of libgcj will call _Jv_CondInit
+// when only a mutex is needed.
+
+inline void
+ensure_condvar_initialized(_Jv_ConditionVariable_t *cv)
+{
+  if (cv->ev[0] == 0)
+    {
+      cv->ev[0] = CreateEvent (NULL, 0, 0, NULL);
+      if (cv->ev[0] == 0) JvFail("CreateEvent() failed");
+
+      cv->ev[1] = CreateEvent (NULL, 1, 0, NULL);
+      if (cv->ev[1] == 0) JvFail("CreateEvent() failed");
+    }
+}
+
+inline void
+ensure_interrupt_event_initialized(HANDLE& rhEvent)
+{
+  if (!rhEvent)
+    {
+      rhEvent = CreateEvent (NULL, 0, 0, NULL);
+      if (!rhEvent) JvFail("CreateEvent() failed");
+    }
+}
+
+// Reimplementation of the general algorithm described at
+// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html (isomorphic to
+// 3.2, not a cut-and-paste).
+
+int
+_Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint nanos)
+{
+  if (mu->owner != GetCurrentThreadId ( ))
+    return _JV_NOT_OWNER;
+
+  _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
+  java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
+
+  // Now that we hold the interrupt mutex, check if this thread has been 
+  // interrupted already.
+  EnterCriticalSection (&current->interrupt_mutex);
+  ensure_interrupt_event_initialized (current->interrupt_event);
+  jboolean interrupted = current_obj->interrupt_flag;
+  LeaveCriticalSection (&current->interrupt_mutex);
+
+  if (interrupted)
+    {
+      return _JV_INTERRUPTED;
+    }
+
+  EnterCriticalSection (&cv->count_mutex);
+  ensure_condvar_initialized (cv);
+  cv->blocked_count++;
+  LeaveCriticalSection (&cv->count_mutex);
+
+  DWORD time;
+  if ((millis == 0) && (nanos > 0)) time = 1;
+  else if (millis == 0) time = INFINITE;
+  else time = millis;
+
+  // Record the current lock depth, so it can be restored
+  // when we reacquire it.
+  int count = mu->refcount;
+  int curcount = count;
+
+  // Call _Jv_MutexUnlock repeatedly until this thread
+  // has completely released the monitor.
+  while (curcount > 0)
+    {  
+      _Jv_MutexUnlock (mu);
+      --curcount;
+    }
+
+  // Set up our array of three events:
+  // - the auto-reset event (for notify())
+  // - the manual-reset event (for notifyAll())
+  // - the interrupt event (for interrupt())
+  // We wait for any one of these to be signaled.
+  HANDLE arh[3];
+  arh[0] = cv->ev[0];
+  arh[1] = cv->ev[1];
+  arh[2] = current->interrupt_event;
+  DWORD rval = WaitForMultipleObjects (3, arh, 0, time);
+
+  EnterCriticalSection (&current->interrupt_mutex);
+
+  // If we were unblocked by the third event (our thread's interrupt
+  // event), set the thread's interrupt flag. I think this sanity
+  // check guards against someone resetting our interrupt flag
+  // in the time between when interrupt_mutex is released in
+  // _Jv_ThreadInterrupt and the interval of time between the
+  // WaitForMultipleObjects call we just made and our acquisition
+  // of interrupt_mutex.
+  if (rval == (WAIT_OBJECT_0 + 2))
+    current_obj->interrupt_flag = true;
+    
+  interrupted = current_obj->interrupt_flag;
+  LeaveCriticalSection (&current->interrupt_mutex);
+
+  EnterCriticalSection(&cv->count_mutex);
+  cv->blocked_count--;
+  // If we were unblocked by the second event (the broadcast one)
+  // and nobody is left, then reset the event.
+  int last_waiter = (rval == (WAIT_OBJECT_0 + 1)) && (cv->blocked_count == 0);
+  LeaveCriticalSection(&cv->count_mutex);
+
+  if (last_waiter)
+    ResetEvent (cv->ev[1]);
+
+  // Call _Jv_MutexLock repeatedly until the mutex's refcount is the
+  // same as before we originally released it.
+  while (curcount < count)
+    {  
+      _Jv_MutexLock (mu);
+      ++curcount;
+    }
+  
+  return interrupted ? _JV_INTERRUPTED : 0;
+}
+
+void
+_Jv_CondInit (_Jv_ConditionVariable_t *cv)
+{
+  // we do lazy creation of Events since CreateEvent() is insanely expensive
+  cv->ev[0] = 0;
+  InitializeCriticalSection (&cv->count_mutex);
+  cv->blocked_count = 0;
+}
+
+void
+_Jv_CondDestroy (_Jv_ConditionVariable_t *cv)
+{
+  if (cv->ev[0] != 0)
+    {
+      CloseHandle (cv->ev[0]);
+      CloseHandle (cv->ev[1]);
+
+      cv->ev[0] = 0;
+    }
+
+  DeleteCriticalSection (&cv->count_mutex);
+}
+
+int
+_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
+{
+  if (mu->owner != GetCurrentThreadId ( ))
+    return _JV_NOT_OWNER;
+
+  EnterCriticalSection (&cv->count_mutex);
+  ensure_condvar_initialized (cv);
+  int somebody_is_blocked = cv->blocked_count > 0;
+  LeaveCriticalSection (&cv->count_mutex);
+
+  if (somebody_is_blocked)
+    SetEvent (cv->ev[0]);
+
+  return 0;
+}
+
+int
+_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
+{
+  if (mu->owner != GetCurrentThreadId ( ))
+    return _JV_NOT_OWNER;
+
+  EnterCriticalSection (&cv->count_mutex);
+  ensure_condvar_initialized (cv);
+  int somebody_is_blocked = cv->blocked_count > 0;
+  LeaveCriticalSection (&cv->count_mutex);
+
+  if (somebody_is_blocked)
+    SetEvent (cv->ev[1]);
+
+  return 0;
+}
+
+//
+// Threads.
+//
+
+void
+_Jv_InitThreads (void)
+{
+  _Jv_ThreadKey = TlsAlloc();
+  _Jv_ThreadDataKey = TlsAlloc();
+  daemon_mutex = CreateMutex (NULL, 0, NULL);
+  daemon_cond = CreateEvent (NULL, 1, 0, NULL);
+  non_daemon_count = 0;
+}
+
+_Jv_Thread_t *
+_Jv_ThreadInitData (java::lang::Thread* obj)
+{
+  _Jv_Thread_t *data = (_Jv_Thread_t*)_Jv_Malloc(sizeof(_Jv_Thread_t));
+  data->flags = 0;
+  data->handle = 0;
+  data->thread_obj = obj;
+  data->interrupt_event = 0;
+  InitializeCriticalSection (&data->interrupt_mutex);
+
+  return data;
+}
+
+void
+_Jv_ThreadDestroyData (_Jv_Thread_t *data)
+{
+  DeleteCriticalSection (&data->interrupt_mutex);
+  if (data->interrupt_event)
+    CloseHandle(data->interrupt_event);
+  CloseHandle(data->handle);
+  _Jv_Free(data);
+}
+
+void
+_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
+{
+  int actual = THREAD_PRIORITY_NORMAL;
+
+  if (data->flags & FLAG_START)
+    {
+      switch (prio)
+        {
+          case 10:
+            actual = THREAD_PRIORITY_TIME_CRITICAL;
+            break;
+          case 9:
+            actual = THREAD_PRIORITY_HIGHEST;
+            break;
+          case 8:
+          case 7:
+            actual = THREAD_PRIORITY_ABOVE_NORMAL;
+            break;
+          case 6:
+          case 5:
+            actual = THREAD_PRIORITY_NORMAL;
+            break;
+          case 4:
+          case 3:
+            actual = THREAD_PRIORITY_BELOW_NORMAL;
+            break;
+          case 2:
+            actual = THREAD_PRIORITY_LOWEST;
+            break;
+          case 1:
+            actual = THREAD_PRIORITY_IDLE;
+            break;
+        }
+      SetThreadPriority(data->handle, actual);
+    }
+}
+
+void
+_Jv_ThreadRegister (_Jv_Thread_t *data)
+{
+  TlsSetValue (_Jv_ThreadKey, data->thread_obj);
+  TlsSetValue (_Jv_ThreadDataKey, data);
+}
+
+void
+_Jv_ThreadUnRegister ()
+{
+  TlsSetValue (_Jv_ThreadKey, NULL);
+  TlsSetValue (_Jv_ThreadDataKey, NULL);
+}
+
+// This function is called when a thread is started.  We don't arrange
+// to call the `run' method directly, because this function must
+// return a value.
+static DWORD WINAPI
+really_start (void* x)
+{
+  struct starter *info = (struct starter *) x;
+
+  _Jv_ThreadRegister (info->data);
+
+  info->method (info->data->thread_obj);
+
+  if (! (info->data->flags & FLAG_DAEMON))
+    {
+      WaitForSingleObject (daemon_mutex, INFINITE);
+      non_daemon_count--;
+      if (! non_daemon_count)
+        SetEvent (daemon_cond);
+      ReleaseMutex (daemon_mutex);
+    }
+
+  return 0;
+}
+
+void
+_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, _Jv_ThreadStartFunc *meth)
+{
+  DWORD id;
+  struct starter *info;
+
+  // Do nothing if thread has already started
+  if (data->flags & FLAG_START)
+    return;
+  data->flags |= FLAG_START;
+
+  info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
+  info->method = meth;
+  info->data = data;
+
+  if (! thread->isDaemon ())
+    {
+      WaitForSingleObject (daemon_mutex, INFINITE);
+      non_daemon_count++;
+      ReleaseMutex (daemon_mutex);
+    }
+  else
+    data->flags |= FLAG_DAEMON;
+
+  data->handle = GC_CreateThread(NULL, 0, really_start, info, 0, &id);
+  _Jv_ThreadSetPriority(data, thread->getPriority());
+}
+
+void
+_Jv_ThreadWait (void)
+{
+  WaitForSingleObject (daemon_mutex, INFINITE);
+  if (non_daemon_count)
+    {
+      ReleaseMutex (daemon_mutex);
+      WaitForSingleObject (daemon_cond, INFINITE);
+    }
+}
+
+//
+// Interrupt support
+//
+
+HANDLE
+_Jv_Win32GetInterruptEvent (void)
+{
+  _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
+  EnterCriticalSection (&current->interrupt_mutex);
+  ensure_interrupt_event_initialized (current->interrupt_event);
+  HANDLE hEvent = current->interrupt_event;
+  LeaveCriticalSection (&current->interrupt_mutex);
+  return hEvent;
+}
+
+void
+_Jv_ThreadInterrupt (_Jv_Thread_t *data)
+{
+  EnterCriticalSection (&data->interrupt_mutex);
+  ensure_interrupt_event_initialized (data->interrupt_event);
+  data->thread_obj->interrupt_flag = true;
+  SetEvent (data->interrupt_event);
+  LeaveCriticalSection (&data->interrupt_mutex);
+}
+

Added: llvm-gcc-4.2/trunk/libjava/win32.cc
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libjava/win32.cc?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libjava/win32.cc (added)
+++ llvm-gcc-4.2/trunk/libjava/win32.cc Thu Nov  8 16:56:19 2007
@@ -0,0 +1,484 @@
+// win32.cc - Helper functions for Microsoft-flavored OSs.
+
+/* Copyright (C) 2002, 2003, 2006  Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+#include <config.h>
+#include <platform.h>
+#include <sys/timeb.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include <java-stack.h>
+
+#include <java/lang/ArithmeticException.h>
+#include <java/lang/UnsupportedOperationException.h>
+#include <java/io/IOException.h>
+#include <java/net/SocketException.h>
+#include <java/util/Properties.h>
+
+static LONG CALLBACK
+win32_exception_handler (LPEXCEPTION_POINTERS e)
+{
+  if (e->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
+    _Jv_ThrowNullPointerException();
+  else if (e->ExceptionRecord->ExceptionCode == EXCEPTION_INT_DIVIDE_BY_ZERO)
+    throw new java::lang::ArithmeticException;
+  else
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+
+// Platform-specific executable name
+static char exec_name[MAX_PATH];
+  // initialized in _Jv_platform_initialize()
+
+const char *_Jv_ThisExecutable (void)
+{
+  return exec_name;
+}
+
+// Helper classes and methods implementation
+  
+#ifdef MINGW_LIBGCJ_UNICODE
+
+// We're using the OS W (UNICODE) API, which means that we're speaking
+// the same language....
+jstring
+_Jv_Win32NewString (LPCTSTR pcsz)
+{
+  return JvNewString ((jchar*) pcsz, _tcslen (pcsz));
+}
+
+#else
+
+// We're using the OS A functions, which means we need to translate between
+// UNICODE and the native character set.
+
+// First, let's set up some helper translation functions....
+
+// Converts the native string to any specified jstring, returning the
+// length of the jstring. If the specified jstring is null, we simply
+// compute and return the length.
+static int nativeToUnicode(LPCSTR pcsz, jstring jstr = 0)
+{
+  jchar* buf = 0;
+  int len = 0;
+  if (jstr)
+    {
+      len = jstr->length();
+      buf = JvGetStringChars(jstr);
+    }
+  return ::MultiByteToWideChar(GetACP(), 0, pcsz,
+    strlen(pcsz), (LPWSTR) buf, len);
+}
+
+// Does the inverse of nativeToUnicode, with the same calling semantics.
+static int unicodeToNative(jstring jstr, LPSTR buf, int buflen)
+{
+  return ::WideCharToMultiByte(GetACP(), 0, (LPWSTR) JvGetStringChars(jstr),
+    jstr->length(), buf, buflen, NULL, NULL);
+}
+
+// Convenience function when the caller only wants to compute the length
+// of the native string.
+static int unicodeToNative(jstring jstr)
+{
+  return unicodeToNative(jstr, 0, 0);
+}
+
+jstring
+_Jv_Win32NewString (LPCTSTR pcsz)
+{
+  // Compute the length, allocate the jstring, then perform the conversion.
+  int len = nativeToUnicode(pcsz);
+  jstring jstr = JvAllocString(len);
+  nativeToUnicode(pcsz, jstr);
+  return jstr;
+}
+
+#endif // MINGW_LIBGCJ_UNICODE
+
+// class _Jv_Win32TempString
+_Jv_Win32TempString::_Jv_Win32TempString(jstring jstr):
+  buf_(0)
+{
+  if (jstr == 0)
+    return;
+    
+  // We need space for the string length plus a null terminator.
+  // Determine whether to use our stack-allocated buffer or a heap-
+  // allocated one.
+#ifdef MINGW_LIBGCJ_UNICODE
+  // A UNICODE character is a UNICODE character is a UNICODE character....
+  int len = jstr->length();
+#else
+  // Compute the length of the native character string.
+  int len = unicodeToNative(jstr);
+#endif // MINGW_LIBGCJ_UNICODE
+
+  int bytesNeeded = (len + 1) * sizeof(TCHAR);
+  if (bytesNeeded <= (int) sizeof(stackbuf_))
+    buf_ = stackbuf_;
+  else
+    buf_ = (LPTSTR) _Jv_Malloc(bytesNeeded);
+    
+#ifdef MINGW_LIBGCJ_UNICODE
+  // Copy the UNICODE characters to our buffer.
+  _tcsncpy(buf_, (LPCTSTR) JvGetStringChars (jstr), len);
+#else
+  // Convert the UNICODE string to a native one.
+  unicodeToNative(jstr, buf_, len);
+#endif // MINGW_LIBGCJ_UNICODE
+
+  buf_[len] = 0;
+}
+
+_Jv_Win32TempString::~_Jv_Win32TempString()
+{
+  if (buf_ && buf_ != stackbuf_)
+    _Jv_Free (buf_);
+}
+
+// class WSAEventWrapper
+WSAEventWrapper::WSAEventWrapper ():
+  m_hEvent(0),
+  m_fd(0),
+  m_dwSelFlags(0)
+{}
+
+WSAEventWrapper::WSAEventWrapper (int fd, DWORD dwSelFlags):
+  m_hEvent(0),
+  m_fd(0),
+  m_dwSelFlags(0)
+{
+  init(fd, dwSelFlags);
+}
+
+void WSAEventWrapper::init(int fd, DWORD dwSelFlags)
+{
+  m_fd = fd;
+  m_dwSelFlags = dwSelFlags;
+  m_hEvent = WSACreateEvent ();
+  if (dwSelFlags)
+    WSAEventSelect(fd, m_hEvent, dwSelFlags);
+}
+
+WSAEventWrapper::~WSAEventWrapper ()
+{
+  if (m_dwSelFlags)
+  {
+    WSAEventSelect(m_fd, m_hEvent, 0);
+    if (m_dwSelFlags & (FD_ACCEPT | FD_CONNECT))
+    {
+      // Set the socket back to non-blocking mode.
+      // Ignore any error since we're in a destructor.
+      unsigned long lSockOpt = 0L;
+        // blocking mode
+      ::ioctlsocket (m_fd, FIONBIO, &lSockOpt);
+    }
+  }
+  WSACloseEvent (m_hEvent);
+}
+
+// Error string text.
+jstring
+_Jv_WinStrError (LPCTSTR lpszPrologue, int nErrorCode)
+{
+  LPTSTR lpMsgBuf = 0;
+
+  DWORD dwFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
+    FORMAT_MESSAGE_FROM_SYSTEM |
+    FORMAT_MESSAGE_IGNORE_INSERTS;
+
+  FormatMessage (dwFlags,
+    NULL,
+    (DWORD) nErrorCode,
+    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+    (LPTSTR) &lpMsgBuf,
+    0,
+    NULL);
+
+  jstring ret;
+  if (lpszPrologue)
+    {
+      LPTSTR lpszTemp =
+        (LPTSTR) _Jv_Malloc ((_tcslen (lpszPrologue) +
+          _tcslen (lpMsgBuf) + 3) * sizeof(TCHAR) );
+      _tcscpy (lpszTemp, lpszPrologue);
+      _tcscat (lpszTemp, _T(": "));
+      _tcscat (lpszTemp, lpMsgBuf);
+      ret = _Jv_Win32NewString (lpszTemp);
+      _Jv_Free (lpszTemp);
+    } 
+  else
+    {
+      ret = _Jv_Win32NewString (lpMsgBuf);
+    }
+
+  LocalFree(lpMsgBuf);
+  return ret;
+}
+
+jstring
+_Jv_WinStrError (int nErrorCode)
+{
+  return _Jv_WinStrError (0, nErrorCode);
+}
+
+void _Jv_ThrowIOException (DWORD dwErrorCode)
+{
+  throw new java::io::IOException (_Jv_WinStrError (dwErrorCode));
+}
+
+void _Jv_ThrowIOException()
+{
+  DWORD dwErrorCode = WSAGetLastError ();
+  _Jv_ThrowIOException (dwErrorCode);
+}
+
+void _Jv_ThrowSocketException (DWORD dwErrorCode)
+{
+  throw new java::net::SocketException (_Jv_WinStrError (dwErrorCode));
+}
+
+void _Jv_ThrowSocketException()
+{
+  DWORD dwErrorCode = WSAGetLastError ();
+  _Jv_ThrowSocketException (dwErrorCode);
+}
+
+// Platform-specific VM initialization.
+void
+_Jv_platform_initialize (void)
+{
+  // Initialise winsock for networking
+  WSADATA data;
+  if (WSAStartup (MAKEWORD (2, 2), &data))
+    MessageBox (NULL, _T("Error initialising winsock library."), _T("Error"),
+    MB_OK | MB_ICONEXCLAMATION);
+
+  // Install exception handler
+  SetUnhandledExceptionFilter (win32_exception_handler);
+
+  // Initialize our executable name.
+  // FIXME: We unconditionally use the ANSI function because
+  // _Jv_ThisExecutable returns a const char*. We should really
+  // change _Jv_ThisExecutable to return a jstring.
+  GetModuleFileNameA(NULL, exec_name, sizeof(exec_name));
+}
+
+// gettimeofday implementation.
+jlong
+_Jv_platform_gettimeofday ()
+{
+  struct timeb t;
+  ftime (&t);
+  return t.time * 1000LL + t.millitm;
+}
+
+jlong
+_Jv_platform_nanotime ()
+{
+  return _Jv_platform_gettimeofday () * 1000LL;
+}
+
+static bool dirExists (LPCTSTR dir)
+{
+  DWORD dwAttrs = ::GetFileAttributes (dir);
+  return dwAttrs != 0xFFFFFFFF &&
+    (dwAttrs & FILE_ATTRIBUTE_DIRECTORY) != 0;
+}
+
+static void getUserHome(LPTSTR userHome, LPCTSTR userId)
+{
+  LPTSTR uh = _tgetenv (_T("USERPROFILE"));
+  if (uh)
+    {
+      _tcscpy(userHome, uh);
+    }
+  else
+    {
+      // Make a half-hearted attempt to support this
+      // legacy version of Windows. Try %WINDIR%\Profiles\%USERNAME%
+      // and failing this, use %WINDIR%.
+      //
+      // See:http://java.sun.com/docs/books/tutorial/security1.2/summary/files.html#UserPolicy
+      //
+      // To do this correctly, we'd have to factor in the
+      // Windows version, but if we did that, then this attempt
+      // wouldn't be half-hearted.
+      TCHAR userHomePath[MAX_PATH], winHome[MAX_PATH];
+      ::GetWindowsDirectory(winHome, MAX_PATH);
+        // assume this call always succeeds
+
+      _stprintf(userHomePath, _T("%s\\Profiles\\%s"), winHome, userId);
+      if (dirExists (userHomePath))
+        _tcscpy(userHome, userHomePath);
+      else
+        _tcscpy(userHome, winHome);
+    }
+}
+
+// Set platform-specific System properties.
+void
+_Jv_platform_initProperties (java::util::Properties* newprops)
+{
+  // A convenience define.
+#define SET(Prop,Val) \
+  newprops->put(JvNewStringLatin1 (Prop), _Jv_Win32NewString (Val))
+
+  SET ("file.separator", _T("\\"));
+  SET ("path.separator", _T(";"));
+  SET ("line.separator", _T("\r\n"));
+
+  // Use GetCurrentDirectory to set 'user.dir'.
+  DWORD buflen = MAX_PATH;
+  TCHAR buffer[buflen];
+  if (buffer != NULL)
+    {
+      if (GetCurrentDirectory (buflen, buffer))
+  SET ("user.dir", buffer);
+
+      if (GetTempPath (buflen, buffer))
+  SET ("java.io.tmpdir", buffer);
+    }
+
+  // Use GetUserName to set 'user.name'.
+  buflen = 257;  // UNLEN + 1
+  TCHAR userName[buflen];
+  if (GetUserName (userName, &buflen))
+    SET ("user.name", userName);
+
+  // Set user.home
+  TCHAR userHome[MAX_PATH];
+  getUserHome(userHome, userName);
+  SET ("user.home", userHome);
+
+  // Get and set some OS info.
+  OSVERSIONINFO osvi;
+  ZeroMemory (&osvi, sizeof(OSVERSIONINFO));
+  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+  if (GetVersionEx (&osvi))
+    {
+      if (buffer != NULL)
+        {
+          _stprintf (buffer, _T("%d.%d"), (int) osvi.dwMajorVersion,
+           (int) osvi.dwMinorVersion);
+          SET ("os.version", buffer);
+        }
+
+      switch (osvi.dwPlatformId)
+        {
+          case VER_PLATFORM_WIN32_WINDOWS:
+            if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
+              SET ("os.name", _T("Windows 95"));
+            else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
+              SET ("os.name", _T("Windows 98"));
+            else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
+              SET ("os.name", _T("Windows Me"));
+            else
+              SET ("os.name", _T("Windows ??"));
+            break;
+
+          case VER_PLATFORM_WIN32_NT:
+            if (osvi.dwMajorVersion <= 4 )
+              SET ("os.name", _T("Windows NT"));
+            else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
+              SET ("os.name", _T("Windows 2000"));
+            else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1)
+              SET ("os.name", _T("Windows XP"));
+            else
+              SET ("os.name", _T("Windows NT ??"));
+            break;
+
+          default:
+            SET ("os.name", _T("Windows UNKNOWN"));
+            break;
+       }
+  }
+
+  // Set the OS architecture.
+  SYSTEM_INFO si;
+  GetSystemInfo (&si);
+  switch (si.wProcessorArchitecture)
+    {
+      case PROCESSOR_ARCHITECTURE_INTEL:
+        SET ("os.arch", _T("x86"));
+        break;
+      case PROCESSOR_ARCHITECTURE_MIPS:
+        SET ("os.arch", _T("mips"));
+        break;
+      case PROCESSOR_ARCHITECTURE_ALPHA:
+        SET ("os.arch", _T("alpha"));
+        break;
+      case PROCESSOR_ARCHITECTURE_PPC:  
+        SET ("os.arch", _T("ppc"));
+        break;
+      case PROCESSOR_ARCHITECTURE_IA64:
+        SET ("os.arch", _T("ia64"));
+        break;
+      case PROCESSOR_ARCHITECTURE_UNKNOWN:
+      default:
+        SET ("os.arch", _T("unknown"));
+        break;
+    }
+}
+
+int
+_Jv_pipe (int filedes[2])
+{
+  return _pipe (filedes, 4096, _O_BINARY);
+}
+
+void
+_Jv_platform_close_on_exec (HANDLE h)
+{
+  // Mark the handle as non-inheritable. This has
+  // no effect under Win9X.
+  SetHandleInformation (h, HANDLE_FLAG_INHERIT, 0);
+}
+
+// Given an address, find the object that defines it and the nearest
+// defined symbol to that address.  Returns 0 if no object defines this
+// address.
+int
+_Jv_platform_dladdr (void *addr, _Jv_AddrInfo *info)
+{
+  // Since we do not have dladdr() on Windows, we use a trick involving
+  // VirtualQuery() to find the module (EXE or DLL) that contains a given
+  // address.  This was taken from Matt Pietrek's "Under the Hood" column
+  // for the April 1997 issue of Microsoft Systems Journal.
+
+  MEMORY_BASIC_INFORMATION mbi;
+  if (!VirtualQuery (addr, &mbi, sizeof (mbi)))
+  {
+    return 0;
+  }
+  
+  HMODULE hMod = (HMODULE) mbi.AllocationBase;
+
+  char moduleName[MAX_PATH];
+
+  // FIXME: We explicitly use the ANSI variant of the function here.
+  if (!GetModuleFileNameA (hMod, moduleName, sizeof (moduleName)))
+  {
+    return 0;
+  }
+
+  char *file_name = (char *)(malloc (strlen (moduleName) + 1));
+  strcpy (file_name, moduleName);
+  info->file_name = file_name;
+
+  // FIXME.
+  info->base = NULL;
+  info->sym_name = NULL;
+  info->sym_addr = NULL;
+
+  return 1;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/ChangeLog
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/ChangeLog?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/ChangeLog (added)
+++ llvm-gcc-4.2/trunk/libmudflap/ChangeLog Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1577 @@
+2007-05-13  Release Manager
+
+	* GCC 4.2.0 released.
+
+2006-12-04  Eric Botcazou  <ebotcazou at libertysurf.fr>
+
+	* configure: Regenerate.
+
+2006-09-18  Tom Tromey  <tromey at redhat.com>
+
+	* configure: Rebuilt.
+
+2006-06-21  Frank Ch. Eigler  <fche at redhat.com>
+
+	PR 21274
+	mf-runtime.h installation based on ssp patch for PR 26473 from
+	Mark Mitchell  <mark at codesourcery.com>.
+	* configure.ac (ACX_NONCANONICAL_TARGET): Use it.
+	* Makefile.am (target_noncanonical): Define.
+	(libsubincludedir): New variable.
+	(nobase_libsubinclude_HEADERS): Add mf-runtime.h.
+	(include_HEADERS): Remove.
+	* configure, aclocal.m4, config.h.in: Regenerated.
+	* Makefile.in, testsuite/Makefile.in: Likewise.
+	* mf-runtime.h: Add #ifndef protection for conflicting _REENTRANT
+	and _THREAD_SAFE redefinition values.
+
+2006-05-23  Carlos O'Donell  <carlos at codesourcery.com>
+
+	* Makefile.am: Add install-html target. Add install-html to .PHONY
+	* Makefile.in: Regenerate.
+
+2006-04-19  Volker Reichelt  <reichelt at igpm.rwth-aachen.de>
+
+	PR mudflap/26789
+	* testsuite/libmudflap.c++/error1-frag.cxx: New test.
+
+	PR mudflap/26790
+	* testsuite/libmudflap.c++/error2-frag.cxx: New test.
+
+2006-04-10  Matthias Klose  <doko at debian.org>
+
+	* testsuite/lib/libmudflap.exp (libmudflap-init): Recognize multilib
+	directory names containing underscores.
+
+2005-11-22  Janis Johnson  <janis187 at us.ibm.com>
+
+	* testsuite/lib/libmudflap.exp (libmudflap-init): Remove -static from
+	MUDFLAP_FLAGS if static library not supported.
+	* testsuite/libmudflap.c/cfrags.exp (MUDFLAP_FLAGS): new.
+	* testsuite/libmudflap.c/externs.exp: Ditto.
+	* testsuite/libmudflap.c++/ctors.exp: Ditto.
+	* testsuite/libmudflap.c++/c++frags.exp: Ditto.
+	* testsuite/libmudflap.cth/cthfrags.exp: Ditto.
+
+2005-10-04  James E Wilson  <wilson at specifix.com>
+
+	* configure.ac (mudflap_cv_entry_point): Use quadrigraphs to declare
+	$name as array of characters with unknown bound.  Also store into the
+	array.
+	* configure: Regenerate.
+
+2005-09-30  James E. Wilson  <wilson at specifix.com>
+
+	* configure.ac (pthread.h): Use AC_CHECK_HEADERS instead of
+	AC_CHECK_HEADER.
+	(target_thread_file): New.  Set from sed'ed gcc output.
+	(posix_threads): New.  Set from target_thread_file.  Use instead of
+	ac_have_pthread_h.
+	(pthread_create_version): Move initialization before code using it.
+	* configure: Regenerate.
+
+	* mf-heuristics.c (_end, ENTRY_POINT): Make them arrays with unknown
+	bounds.
+
+2005-09-29  James E. Wilson  <wilson at specifix.com>
+
+	* mf-hooks1.c (__mf_0fn_mmap, mmap, __mf_0fn_munmap, munmap): Protect
+	with HAVE_MMAP ifdef.
+
+2005-09-23  Frank Ch. Eigler  <fche at elastic.org>
+
+	PR 23084.
+	* mf-hooks2.c (accept): Tolerate NULL sockaddr* parameter.
+
+2005-09-23  Frank Ch. Eigler  <fche at elastic.org>
+
+	* testsuite/libmudflap.c++/pass58-frag.cxx: New test for heisenbug 19319.
+
+2005-09-23  Tom Tromey  <tromey at redhat.com>
+
+	* aclocal.m4, configure: Rebuilt.
+	* configure.ac: Use GCC_CHECK_TLS.
+	* acinclude.m4 (LIBMUDFLAP_CHECK_TLS, LIBMUDFLAP_ENABLE): Moved
+	to ../config.
+
+2005-08-22  Jim Wilson  <wilson at specifix.com>
+
+	* mf-hooks2.c (MF_REGISTER_fopen): Define to __MF_TYPE_STATIC when
+	__FreeBSD__ is defined.
+
+2005-08-17  Jim Wilson  <wilson at specifix.com>
+
+	* mf-hooks1.c (malloc, calloc, realloc, free,
+	__mf_wrap_alloca_indirect): Call BEGIN_MALLOC_PROTECT before calling
+	the real routines, and END_MALLOC_PROTECT afterwards.
+	* mf-impl.h (enum __mf_state_enum): Expand comment.  Add in_malloc.
+	(BEGIN_PROTECT): Handle in_malloc state.
+	(BEGIN_MALLOC_PROTECT, END_MALLOC_PROTECT): New.
+	* testsuite/libmudflap.c/hook2-allocstuff.c: New.
+
+2005-08-17  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* All files: Update FSF address.
+
+2005-08-15  Ulrich Weigand  <weigand at informatik.uni-erlangen.de>
+
+	* mf-hooks3.c (main_seen_p): Remove.
+	(__mf_get_state): Remove attempt to recognize the main thread.
+
+2005-08-15  Maciej W. Rozycki  <macro at linux-mips.org>
+
+	* configure.ac: Test for the name of the symbol used for the entry
+	point; define ENTRY_POINT to the result.
+	* configure: Regenerate.
+	* config.h.in: Regenerate.
+	* mf-heuristics.c: Replace _start with ENTRY_POINT throughout.
+
+2005-08-14  Ulrich Weigand  <weigand at informatik.uni-erlangen.de>
+
+	* mf-runtime.c (__mf_state_1): Initialize to reentrant.
+	(__mf_init): Set thread state active.
+	* mf-hooks3.c (__mf_pthread_spawner): Always set thread
+	state active.
+	(pthread_create wrapper): Always use thread spawner.
+
+	* testsuite/libmudflap.cth/pass37-frag.c: Increase timeout.
+	* testsuite/libmudflap.cth/pass39-frag.c: Likewise.
+
+2005-07-16  Richard Henderson  <rth at redhat.com>
+
+	* acinclude.m4: New file.
+	* configure.ac: Invoke LIBMUDFLAP_CHECK_TLS.
+	* configure, config.h.in, Makefile.in, testsuite/Makefile.in: Rebuild.
+	* mf-hooks1.c (__mf_0fn_malloc): Move body from ...
+	(__mf_0fn_calloc): ... here.
+	* mf-hooks3.c (struct pthread_info): Remove.
+	(__mf_pthread_info, __mf_pthread_info_idx): Remove.
+	(LIBMUDFLAPTH_THREADS_MAX): Set to 1021.
+	(struct mf_thread_data): New.
+	(mf_thread_data, mf_thread_data_lock): New.
+	(__mf_allocate_blank_threadinfo): Remove.
+	(__mf_find_threadinfo): Rewrite and simplify.  Only use if TLS is
+	not available.
+	(__mf_state_perthread): Remove.
+	(__mf_get_state, __mf_set_state): New.
+	(__mf_pthread_cleanup): Use &errno, rather than saved pointer.
+	Update mf_thread_data killing procedure.
+	(__mf_pthread_spawner): Similarly.
+	(__mf_0fn_pthread_create): Only use wrapper if necessary.  Remove
+	code to allocate thread stack space.
+	(__mf_0fn_pthread_join, pthread_join): Remove.
+	(__mf_0fn_pthread_exit, pthread_exit): Remove.
+	* mf-impl.h (dyn_pthread_join, dyn_pthread_exit): Remove.
+	(__mf_state_1): Rename from __mf_state; use TLS when available.
+	(__mf_get_state, __mf_set_state): New.  Update all users.
+	* mf-runtime.c (begin_recursion_protect1): New.
+	(BEGIN_RECURSION_PROTECT): Use it.
+	(__mf_state_1): Rename from __mf_state; use TLS when available.
+	(threads_active_p): Remove.
+	(__mf_usage): Compute it directly.
+
+2005-06-19  Ulrich Weigand  <uweigand at de.ibm.com>
+
+	* testsuite/libmudflap.c/externs-1.c (main): Add return statement.
+
+2005-06-15  Frank Ch. Eigler  <fche at redhat.com>
+
+	Fix for uncaching bug reported by Herman ten Brugge.
+	* mf-runtime.c (__mf_uncache_object): Search whole cache.
+	* testsuite/libmudflap.c/fail40-frag.c: New test.
+
+2005-05-23  Alfred M. Szmidt  <ams at gnu.org>
+
+	PR libmudflap/21724
+	* Makefile.am (AM_MAKEFLAGS): Pass includedir.
+	* Makefile.in: Amend.
+
+2005-06-14  Frank Ch. Eigler  <fche at redhat.com>
+
+	PR mudflap/21023
+	* testsuite/libmudflap.c/externs.exp, externs-{1,2}.c: New test files.
+	* testsuite/libmudflap.c/cfrags.exp: Bypass new sources.
+
+2005-06-14  Frank Ch. Eigler  <fche at redhat.com>
+
+	PR libmudflap/21094
+	* testsuite/libmudflap.c++/*.exp: Assert build tree g++.
+
+2005-06-14  Frank Ch. Eigler  <fche at redhat.com>
+
+	PR mudflap/22064
+	* mf-impl.h (mudflap_mode, violation_mode): Make these ordinary
+	unsigned vars with #defines instead of enums.
+
+2005-05-09  Mike Stump  <mrs at apple.com>
+
+	* configure: Regenerate.
+
+2005-04-12  Mike Stump  <mrs at apple.com>
+
+	* configure: Regenerate.
+
+2005-04-12  Frank Ch. Eigler  <fche at redhat.com>
+
+	PR mudflap/19266
+	* testsuite/libmudflap.c++/c++frags.exp: Also test -O permutation.
+	* testsuite/libmudflap.c++/pass57-frag.cxx: New test.
+
+2005-04-04  Alan Modra  <amodra at bigpond.net.au>
+
+	* mf-runtime.c (__mfu_unregister): Warning fix for char unsigned.
+
+2005-03-31  Mike Stump  <mrs at apple.com>
+
+	* mf-runtime.h: Add libmudflap copyright clause.
+
+2005-03-21  Mike Stump  <mrs at apple.com>
+
+	* mf-heuristics.c: Fix whitespace at end of line.
+	* mf-hooks1.c: Likewise.
+	* mf-hooks2.c: Likewise.
+	* mf-hooks3.c: Likewise.
+	* mf-impl.h: Likewise.
+	* mf-runtime.c: Likewise.
+	* mf-runtime.h: Likewise.
+
+2005-03-21  Zack Weinberg  <zack at codesourcery.com>
+
+	* configure.ac: Do not invoke TL_AC_GCC_VERSION.
+	In all substitutions, expand gcc_version in Makefile.
+	* aclocal.m4, configure: Regenerate.
+	* Makefile.am: Set gcc_version.
+	* Makefile.in, testsuite/Makefile.in: Regenerate.
+
+2005-03-17  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (__mfu_check): Respect ignore_reads configuration.
+	* testsuite/libmudflap.c/{pass56,fail39}-frag.c: New tests.
+
+2005-02-13  Frank Ch. Eigler  <fche at redhat.com>
+
+	PR mudflap/19319
+	* testsuite/libmudflap.c++/pass55-frag.c: New test.
+
+2005-01-05  Richard Henderson  <rth at redhat.com>
+
+	* testsuite/libmudflap.c/pass32-frag.c: Fix typo.
+
+2005-01-02  Greg McGary  <greg at mcgary.org>
+
+	* mf-impl.h (uintptr_t): Get typedef via stdint.h or define explicitly.
+	* mf-runtime.h: New file, replaces mf-runtime.h.in.
+	* configure.ac (AC_CONFIG_FILES): mf-runtime.h is no longer generated.
+	* Makefile.in: Ditto.
+	* testsuite/lib/libmudflap.exp: Add -I${srcdir}/.. to get mf-runtime.h
+	* testsuite/libmudflap.c/pass32-frag.c: s/uintptr_t/__mf_uintptr_t/
+	* testsuite/libmudflap.c/fail36-frag.c: New test.
+	* testsuite/libmudflap.c/fail37-frag.c: New test.
+	* testsuite/libmudflap.c/fail38-frag.c: New test.
+
+2004-12-08  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* Makefile.am: Add ../config to ACLOCAL_AMFLAGS.
+	* aclocal.m4, Makefile.in, testsuite/Makefile.in: Regenerate.
+
+2004-12-02  Richard Sandiford  <rsandifo at redhat.com>
+
+	* configure.ac: Use TL_AC_GCC_VERSION to set gcc_version.
+	* aclocal.m4: Include ../config/gcc-version.m4.
+	* configure, Makefile.in, testsuite/Makefile.in: Regenerate.
+
+2004-11-29  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* Makefile.am: Define ACLOCAL_AMFLAGS.
+	* acinclude.m4: Remove.
+	* stamp-h.in: Remove superfluous stamp file.
+	* aclocal.m4, configure, Makefile.in: Regenerate.
+	* testsuite/Makefile.in: Likewise.
+
+2004-11-24  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* Makefile.am: Revert previous.
+	* acinclude.m4: Restore.
+	* aclocal.m4, configure, Makefile.in: Regenerate.
+	* testsuite/Makefile.in: Likewise.
+
+2004-11-24  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* Makefile.am: Define ACLOCAL_AMFLAGS.
+	* acinclude.m4: Remove.
+	* aclocal.m4, configure, Makefile.in: Regenerate.
+	* testsuite/Makefile.in: Likewise.
+
+2004-11-23  John David Anglin  <dave.anglin at nrc-cnrc.gc.ca>
+
+	* testsuite/lib/libmudflap.exp: Use new procs in target-libpath.exp.
+
+2004-11-23  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* Makefile.in, configure, aclocal.m4: Regenerate with automake 1.9.3.
+	* testsuite/Makefile.in: Likewise.
+
+2004-11-01  Andreas Schwab  <schwab at suse.de>
+
+	* configure.ac: (target_alias): Default to $host_alias, not
+	$target.
+	* configure: Regenerated.
+
+2004-10-28  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/fail35-,pass53-,pass54-frag.c: New tests.
+	* testsuite/libmudflap.c/pass35-frag.c: Correct embedded warning
+	message.
+
+2004-10-25  Eric Botcazou  <ebotcazou at libertysurf.fr>
+
+	PR other/18138
+	* testsuite/lib/libmudflap.exp: Accept more than one multilib libgcc.
+
+2004-10-12  Frank Ch. Eigler  <fche at 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.
+
+2004-10-05  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.ac: Checking for sys/socket.h once is enough.
+	* configure: Regenerated.
+
+2004-10-04  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.ac: Look for more headers & functions.
+	* mf-hooks2.c (getmntent, inet_ntoa, getproto*): New wrapper functions.
+	* mf-runtime.h.in: Add new "#pragma redefine_extname"s for them.
+	* mf-runtime.c (options): Clean up integer signedness warnings.
+	(main): Add a declaration to fix a warning.
+	* mf-hooks3.c (pthread_exit): Add not-reached exit() to wrapper.
+	* configure, config.h.in: Regenerated.
+
+2004-10-02  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/pass50-frag.c, fail33-frag.c, fail34-frag.c:
+	New tests for proper base/limit checking for aggregates.
+
+2004-09-15  Joseph S. Myers  <jsm at polyomino.org.uk>
+
+	* testsuite/libmudflap.c/pass35-frag.c: Update expected message.
+
+2004-09-07  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.ac: Look for pwd.h, grp.h, netdb.h headers and functions.
+	* mf-hooks2.c (strerror): Unregister previous string returned by
+	previous strerror.
+	(getlogin,cuserid,getpwnam,getpwuid,getgrnam,getgrgid): New wrappers.
+	(getservent,getservbyname,getservbyport,gai_strerror): Ditto.
+	* mf-runtime.h.in: Add redefine_extname pragmas for them all.
+	* mf-runtime.c (__mf_describe_object): Clarify object life status.
+	* testsuite/libmudflap.c/pass48-frag.c, pass49-frag.c, fail32-frag.c:
+	New tests.
+	* configure, config.h.in: Regenerated.
+
+2004-08-03  Dale Johannesen  <dalej at apple.com>
+
+	 * mf-runtime.c: Conditionalize POSIX_SOURCE for Darwin.
+
+2004-08-03  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (compare_uintptr_t): Remove function.  Inline
+	simplified contents in all former callers.
+
+2004-07-27  Ulrich Weigand  <weigand at informatik.uni-erlangen.de>
+
+	* mf-runtime.c (__mf_fini): Set mudflap_mode to mode_nop in
+	the statically linked case.
+
+2004-07-27  Frank Ch. Eigler  <fche at redhat.com>
+
+	* splay-tree.[ch]: Remove.  Merge contents into ...
+	* mf-runtime.c: ... here, renaming symbols and making all functions
+	static.  Remove unused min/max functions.
+	* Makefile.am: Forget about splay-tree.[ch].
+	* Makefile.in, testsuite/Makefile.in: Regenerated.
+
+2004-07-21  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (__mfu_check): Remove mistaken mode-nop handling.
+	(__mfu_usage): Include (C) 2004.
+	* mf-hooks3.c (__mf_find_threadinfo): Don't call tracing functions
+	here.  Include a comment explaining why.
+
+2004-07-20  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-impl.h (__mf_options): Add ignore_reads and timestamps fields.
+	* mf-runtime.c (options): Give them a name.
+	(__mf_set_default_options): Set them.
+	(__mf_insert_new_object, __mfu_unregister): Optionalize timestamps.
+	(__mf_violation): Warning cleanup.
+	* mf-impl.h (MF_VALIDATE_EXTENT): Support ignore_reads option.
+	* splay-tree.c (splay_tree_delete_helper): Remove obsolete decl.
+
+2004-07-15  Frank Ch. Eigler  <fche at redhat.com>
+
+	g++/15861
+	* mf-runtime.c (__mf_init): Make it non-static.  Tolerate
+	repeated invocation.
+
+2004-07-09  Frank Ch. Eigler  <fche at redhat.com>
+
+	Test case for g++/15861
+	* testsuite/libmudflap.c++/ctors-[12].cxx: New test case halves.
+	* testsuite/libmudflap.c++/ctors.exp: Driver.
+	* testsuite/libmudflap.c++/c++frags.exp: Elide redundant default.
+	Look only for *frag* test cases.
+
+2004-07-08  Frank Ch. Eigler  <fche at redhat.com>
+
+	ANSI C conversion, libmudflap specialization, recursion limiting.
+	* splay-tree.h (splay_tree_{de,}allocate_fn): Remove allocation_data
+	argument and indirection function pointers, update callers.
+	(splay_tree_s): Add statistics and recursion control fields
+	num_keys, max_depth, depth, rebalance_p.
+	* splay-tree.c (splay_tree_splay_helper): Track recursion depth.
+	Back out of search if it exceeds limit.
+	(splay_tree_splay): Manage recursion limiting with rebalancing as
+	needed.
+	(splay_tree_new): More initialization.
+	(splay_tree_rebalance): New function.
+	(splay_tree_foreach): Rewrite using nonrecursive logic.
+	(splay_tree_xmalloc_allocate, splay_tree_xmalloc_deallocate):
+	Remove.  Point indirect calls to mf-runtime.c's routines.
+	(splay_tree_compare_ints, splay_tree_compare_pointers): Remove unused
+	functions.
+	(splay_tree_delete, splay_tree_delete_helper): Ditto.
+	* testsuite/heap-scalestress.c: New test based on one from
+	Eyal Lebedinsky <eyal at eyal.emu.id.au>:
+
+2004-07-05  Matthias Klose  <doko at debian.org>
+
+	* libtool-version: New.
+	* Makefile.am (libmudflap_la_LDFLAGS, libmudflapth_la_LDFLAGS):
+	Use -version-info for soname.
+	* Makefile.in: Regenerate.
+	* configure.ac: Remove libtool_VERSION macro
+	* configure: Regenerate
+
+2004-07-05  Zack Weinberg  <zack at codesourcery.com>
+
+	* mf-runtime.h.in: Wrap declarations of struct __mf_cache,
+	__mf_lookup_cache, __mf_lc_mask, or __mf_lc_shift in
+	#ifndef _MUDFLAP.
+
+2004-06-29  Frank Ch. Eigler  <fche at redhat.com>
+
+	Splay tree implementation fork.
+	* splay-tree.c, splay-tree.h: Copied & modified from libiberty.
+	Use hard-coded comparison function for uintptr_t.  Remove key/value
+	deallocation logic.  Cache last splayed key for consecutive lookups.
+	* Makefile.am, Makefile.in: Use them, don't link to them.
+	* mf-runtime.c (__mf_object_tree): Adapt to simpler splay_tree_new.
+	(__mf_find_objects2): Flip successor/predecessor search sequence.
+	* ansidecl.h, libiberty.h: Removed dummy files.
+
+2004-06-29  Nick Clifton  <nickc at redhat.com>
+
+	* configure.ac (AC_CHECK_HEADERS): Add dirent.h
+	* configure: Regenerate.
+	* mf-hooks2.c: Surround uses of dirent.h with #ifdef
+	HAVE_DIRENT_H.
+	Remove spurious inclusion of <strings.h>.
+
+2004-06-29  Nick Clifton  <nickc at redhat.com>
+
+	* mf-runtime.c (pthread_join): Only apply the weak pragma if the
+	function actually exists.
+
+2004-06-25  Frank Ch. Eigler  <fche at redhat.com>
+
+	* ansidecl.h, libiberty.h: New dummy files for building splay-tree.
+	* config.h.in: Regenerated.
+
+2004-06-24  Frank Ch. Eigler  <fche at redhat.com>
+
+	Adopt splay trees for object database.
+	* Makefile.am: Copy splay-tree.* from libiberty.
+	* Makefile.in, testsuite/Makefile.in: Regenerated.
+	* mf-runtime.h.in (__mf_unregister): Add third parameter (type).
+	* mf-hooks[123].c (*): Add new third parameter to mf_unregister.
+	* mf-impl.h (BEGIN_PROTECT): Remove some trace text.
+	* mf-runtime.c: Rewrite code dealing with object database to use
+	libiberty splay trees.  Remove tree liveness aging option.
+	* testsuite/libmudflap.c/fail18-frag.c: Add volatile flag.
+
+2004-06-15  Paolo Bonzini  <bonzini at gnu.org>
+
+	* configure.ac: New name of configure.in.  Update
+	AC_INIT, AC_CONFIG_SRCDIR, AC_CONFIG_HEADERS, AC_CONFIG_FILES,
+	AC_OUTPUT, AM_INIT_AUTOMAKE to the preferred style for
+	Autoconf 2.5x and Automake 1.7 or later.
+	* configure.in: Remove.
+	* configure: Regenerate.
+
+	* Makefile.am: Remove useless multilib rules.
+	* Makefile.in: Regenerate.
+
+2004-06-15  Paolo Bonzini  <bonzini at gnu.org>
+
+	* .cvsignore: New file.
+
+2004-06-10  Stephen Crowley  <stephen.crowley at sbcglobal.net>
+
+	PR libmudflap/13505
+	* mf-hooks2.c (semctl): Add cygwin porting hack.
+
+2004-06-09  Frank Ch. Eigler  <fche at redhat.com>
+
+	ctype support.
+	* configure.in: Look for ctype header and glibc implementation.
+	* mf-hooks2.c (__ctype_{b,toupper,tolower}_loc): Sample ctype
+	array hooks for glibc 2.3.
+	* mf-runtime.h.in: Wrap them.
+	* mf-runtime.c (__mf_init): Leave marker regarding other ctype
+	implementations.
+	* testsuite/libmudflap.c/pass47-frag.c: New test.
+	* configure, config.h.in: Regenerated.
+
+2004-06-04  Frank Ch. Eigler  <fche at redhat.com>
+
+	Portability improvements, e.g., libmudflap/15293.
+	* configure.in: Look for glibc extension functions.  Look for
+	support of -f{function,data}-sections.  Look for more headers.
+	Create testsuite/mfconfig.exp.  Correct more "test x.." thinkos.
+	* Makefile.am: Use $(SECTION_FLAGS).  Collapse piecemeal-compiled
+	mf-hooks* into usual single object per source.
+	* mf-hooks*.c: Remove all #if WRAP_foo conditionals.
+	* mf-hooks2.c: #include a bunch more system headers.  Define strnlen
+	if system doesn't provide one.
+	* mf-hooks3.c (struct pthread_info): Add stack_*_alloc fields.
+	(pthread_create): Use it to properly GC dead thread stacks.
+	* mf-runtime.c (__mf_violation): Correct snprintf type warning.
+	* testsuite/Makefile.am: Stop generating site.exp.
+	* testsuite/mfconfig.exp.in: New file.
+	* testsuite/config/default.exp: Load new mfconfig.exp.
+	* testsuite/lib/libmudflap.exp (libmudflap-init): Add extra libraries.
+	(prune_gcc_output): Add glibc static linking warnings.
+	* testsuite/libmudflap.*/*frags.exp: Enumerate needed -lmudflap* libs.
+	* testsuite/libmudflap.c/pass46-frag.c: Ditto.
+	* configure, Makefile, aclocal.m4, config.h.in, testsuite/Makefile.in:
+	Regenerated with autoconf 2.57 and automake 1.7.
+
+2004-06-04  Per Bothner  <per at bothner.com>
+
+	* configure.in (LIBMUDFLAPTH):  Fix thinko.
+
+	* configure.in:  Check for more headers.
+	* mf-hooks2.c:  Conditionalize on HAVE_SYS_SOCKET_H etc.
+
+	* mf-runtime.c:  In two places conditionalize on SIUSR1 rather than
+	HAVE_SIGNAL as mingw has signal.h but not SIUSR1.
+
+2004-06-01  Andreas Jaeger  <aj at suse.de>
+
+	* configure.in: Handle multilibs, support
+	--enable-version-specific-runtime-libs.
+	* Makefile.am (lib_LTLIBRARIES): Rename to ...
+	(toolexeclib_LTLIBRARIES): this for multilib support.
+	* Makefile.in: Regenerated.
+	* configure: Regenerated.
+	* aclocal.m4: Regenerated.
+	* config.h.in: Regenerated.
+	* testsuite/Makefile.in: Regenerated.
+
+2004-06-01  Andreas Jaeger  <aj at suse.de>
+
+	* testsuite/lib/libmudflap.exp (libmudflap-init): Handle
+	multilibs, using multilib directory instead of hardcoded path.
+	Set LD_RUN_PATH.
+
+2004-05-21  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am (AM_MAKEFLAGS): Pass RUNTESTFLAGS.
+	* Makefile.in: Ditto.
+
+2004-05-18  Kaz Kojima  <kkojima at gcc.gnu.org>
+
+	* acinclude.m4 (lt_cv_deplibs_check_method): Use pass_all on sh*.
+	* aclocal.m4, configure: Rebuilt.
+
+2004-05-17  Frank Ch. Eigler  <fche at redhat.com>
+
+	* lib/libmudflap.exp (libmudflap-init): For C++ test cases only,
+	import some build settings from libstdc++-v3 testsuite_flags.
+	* .../cfrags.exp, .../c++frags.exp, .../cthfrags.exp: Corresponding
+	changes to pass test language.
+
+	* mf-runtime.c (__mfu_check): Poison the cache with antidote for
+	quicker mode-nop handling.
+
+2004-03-25  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-impl.h: Added libgcc license header.
+
+2004-03-20  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks[123].c, mf-runtime.c, mf-heuristics.c:
+	Added libgcc license header.
+	* mf-hooks3.c (__mf_0fn_pthread_create): Correct arg constness.
+	(pthread_create): Simplify stack allocation syntax.
+
+2004-03-08  Loren J. Rittle  <ljrittle at acm.org>
+
+	* mf-hooks2.c: Support FreeBSD.
+	(WRAP_gets): Avoid gets().
+	* testsuite/libmudflap.c/pass-stratcliff.c: Do not
+	test unimplemented mem/str calls on FreeBSD.
+	* testsuite/libmudflap.c/pass21-frag.c: Do not include
+	<alloca.h> on FreeBSD.
+
+2004-01-30  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/pass36-frag.c: Add missing free() call.
+	* testsuite/libmudflap.c/pass46-frag.c: New test for -fmudflapir.
+	* testsuite/libmudflap.cth/cthfrags.exp: Add -DSTATIC to compiler
+	flags for static linking permutation.
+	* testsuite/libmudflap.cth/pass40-frag.c: When -DSTATIC, avoid
+	some pthreads code that croaks on linux glibc tls.
+
+2004-01-27  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/fail31-frag.c, pass45-frag.c: New tests.
+
+2004-01-15  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/pass44-frag.c: New test.
+
+2004-01-12  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/fail{28,29,30}-frag.c: New tests.
+
+2004-01-08  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/pass43-frag.c: Added missing program rc.
+
+2003-12-11  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/pass42-frag.c, pass43-frag.c: New tests.
+
+2003-12-08  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR libmudflap/12670
+	* configure.in: Add check for see if
+	socklen_t typedef is in sys/socket.h.
+	* mf-hooks1.c: Add define if socklen_t
+	is not typedef.
+	* mf-hooks2.c: Likewise.
+	* mf-hooks3.c: Likewise.
+	* config.h.in: Regen.
+	* configure: Regen.
+
+2003-12-08  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (__mf_watch_or_not): Tweak tracing message.
+	* testsuite/libmudflap.c/fail21-frag.c: Defeat aliasing
+	optimizations.
+	* testsuite/libmudflap.c/pass25-frag.c: Ditto.
+	* testsuite/libmudflap.c/pass26-frag.c: Tolerate non-overlapping
+	(unoptimized) allocation of stack space.
+
+2003-12-07  Richard Henderson  <rth at redhat.com>
+
+	* testsuite/libmudflap.c/fail23-frag.c (main): Adjust addend to 11.
+	* testsuite/libmudflap.c/fail27-frag.c (foo): Mark noinline.
+
+2003-12-06  Andrew Pinski <apinski at apple.com>
+
+	partial PR libmudflap/12670
+	* mf-hooks1.c: Respect Darwin checks.  Conditionalize POSIX_SOURCE.
+	* mf-hooks2.c: Likewise.
+	* mf-hooks3.c: Likewise.
+
+2003-11-19  Frank Ch. Eigler  <fche at redhat.com>
+
+	libstdc++/11696
+	* mf-runtime.h.in: Switch to #pragma redefine_extname for
+	symbols interposed at compile time.
+	* testsuite/libmudflap.c++/pass41-frag.cxx: New test.
+
+	libmudflap/12939
+	* mf-hooks2.c (semctl): Tolerate FreeBSD.
+
+	* configure.in: Reorganize check for <pthread.h>.
+	* configure: Regenerated.
+
+2003-11-04  David Edelsohn  <edelsohn at gnu.org>
+
+	* mf-runtime.c (_ALL_SOURCE): Define for AIX.
+	(_LARGE_FILE_API): Define for AIX.
+	* mf-hooks[123]: Same.
+	(_XOPEN_SOURCE_EXTENDED): Define to 1 for AIX.
+
+2003-10-21  David Edelsohn  <edelsohn at gnu.org>
+
+	* mf-runtime.c (_XOPEN_SOURCE_EXTENDED): Define to 1 for AIX.
+
+2003-07-29  Frank Ch. Eigler  <fche at redhat.com>
+
+	2003-07-29  Gerald Pfeifer  <pfeifer at dbai.tuwien.ac.at>
+
+	* configure.in: Update check for union semun.
+
+2003-07-29  Gerald Pfeifer  <pfeifer at dbai.tuwien.ac.at>
+
+	PR other/11673
+	* mf-hooks2.c [WRAP_semctl]: Fix check for HAVE_UNION_SEMUN.
+
+2003-07-29  Frank Ch. Eigler  <fche at redhat.com>
+
+	PR other/11673
+	* configure.in: Add checks for 64-bit LFS functions, struct semun
+	definition, for BSD compatibility.
+	* mf-hooks1.c: Respect BSD checks.  Conditionalize POSIX_SOURCE.
+	* mf-hooks2.c: Ditto.  Include <strings.h> for bcmp* decls.
+	* mf-hooks3.c: Ditto.
+	(pthread_create): Try MAP_ANON on platforms without the MAP_ANONYMOUS
+	mmap flag.
+	* configure, config.h.in: Regenerated.
+
+2003-07-23  Frank Ch. Eigler  <fche at redhat.com>
+
+	Multithreading fixes:
+	* mf-runtime.c (__mf_object): Store allocating/deallocating
+	thread id.
+	(options): Support new "-thread-stack" option.
+	Rename "-heur-argv-environ" option to "-heur-stdlib".
+	Disable "-lc-mask" and "-lc-shift" options.
+	(__mf_dynamic): Add function pointers for pthread_join/_exit.
+	(__assert_fail): New self-contained function for glibc.
+	* mf-hooks3.c: Essentially rewritten, particularly related to
+	use of __mf_pthread_info array.
+	(pthread_join, _exit): New hook functions.
+	* mf-impl.h (BEGIN_PROTECT): Handle starting_p case.
+	* testsuite/libmudflap.cth/pass40-frag.c: New test.
+
+	Warning cleanups:
+	* mf-heuristics.c: Add type casts for tracing, sub calls.
+	* mf-impl.h (BEGIN_PROTECT): Redefine to omit result type.
+	Update all callers to declare explicit result holder.
+	(END_PROTECT): Removed.
+	* testsuite/*/*frags.exp: Clean up default MUDFLAP_OPTIONS.
+
+2003-07-15  Diego Novillo  <dnovillo at redhat.com>
+
+	* testsuite/libmudflap.c/fail21-frag.c: Add volatile modifiers.
+	* testsuite/libmudflap.c/fail15-frag.c: Likewise.
+	* testsuite/libmudflap.c/fail13-frag.c: Likewise.
+
+2003-07-04  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks1.c, 2.c, 3.c: New file, splits up content from old ...
+	* mf-hooks: Removed.
+	* mf-impl.h (MF_VALIDATE_EXTENT, BEGIN_PROTECT, END_PROTECT):
+	Move these macros from old mf-hooks.c here.
+	* Makefile.am: Adapt to split-up hook sources for faster builds.
+	* Makefile.in: Regenerated.
+
+	* mf-heuristics.c: Remove #if-0 block.
+
+	* mf-impl.h (__mf_state): Reorganize declaration and implementation.
+	(__mf_starting_p): New state only for use while dlsym bootstrapping.
+	(CALL_REAL, __mf_init): Corresponding changes.
+	(TRACE, VERBOSE_TRACE): Include thread id and "mf:" prefix.  Update
+	all callers to remove redundant "mf:" prefix.
+	* mf-runtime.h.in: #define a few reentrancy macros for libmudflapth.
+	* mf-hooks3.c: Rewrite chunks to support per-thread __mf_state value.
+	(__mf_pthread_info): Become a hash table.
+
+	* testsuite/lib/mfdg.exp: Support new "dg-timeout" and
+	"dg-repetitions" directives to control test case execution.
+	* testsuite/libmudflap.cth/pass37-frag.c: Add timeout and repeat
+	options.
+	* testsuite/libmudflap.cth/pass39-frag.c: Ditto for this new test.
+
+2003-06-25  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (alloca): Separate into stub.
+	(__mf_wrap_alloca_indirect): New function.  Use CALL_REAL
+	malloc/free for alloca blocks.
+	(pthread_create): Tolerate failing pthread_attr_get* calls.
+	* mf-runtime.c (__mf_fini): Call __mf_wrap_alloca_indirect.
+	* mf-impl.h (CALL_WRAP): Remove macro.
+	* testsuite/libmudflap.c/pass21-frag.c: Include <alloca.h>.
+	* testsuite/libmudflap.c/pass23-frag.c: Include more struct
+	padding for ia64 BIT_FIELD_REF constructs.
+
+2003-06-19  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (struct pthread_info): Add "thread_errno" field.
+	(__mf_pthread_spawner, __mf_pthread_cleanup): Use it with GUESS
+	libmudflap object type.
+	* mf-runtime.c (__mfu_unregister): Correct cemetary logic to avoid
+	crashes on unregistering STATIC objects.
+
+2003-06-17  Frank Ch. Eigler  <fche at redhat.com>
+
+	Based on patch from Eyal Lebedinsky <eyal at eyal.emu.id.au>:
+	* mf-hooks.c (__mf_pthread_spawner): Register thread errno.
+	(time, strerror, fopen, fopen64, fclose, fread): New hooks.
+	(fwrite, fgetc, fgets, getc, gets, ungetc, fputc): New hooks.
+	(fputs, putc, puts, clearerr, feof, ferror, fileno): New hooks.
+	(printf, fprintf, sprintf, snprintf, vprintf, vfprintf): New hooks.
+	(vsprintf, vsnprintf, access, remove, fflush, fseek): New hooks.
+	(fseeko64, ftell, ftello64, rewind, fgetpos, fsetpos): New hooks.
+	(stat, stat64, fstat, lstat, mkfifo, setvbuf, setbuf): New hooks.
+	(setvbuf, opendir, closedir, readdir, recv, recvfrom): New hooks.
+	(recvmsg, send, sendto, sendmsg, setsockopt, getsockopt): New hooks.
+	(accept, bind, connect, gethostname, sethostname): New hooks.
+	(gethostbyname, wait, waitpid, popen, pclose, execve): New hooks.
+	(execv, execvp, system, dlopen, dlclose, dlerror, dlsym): New hooks.
+	(semop, semctl, shmctl, shmat, shmdt): New hooks.
+	* mf-runtime.h.in: Corresponding changes.
+	* mf-runtime.c (__mf_ini): Register stdio objects.  Use STATIC type.
+	(opts) Rename heur_argv_environ	to heur_std_data.
+	(__mf_wrap_main): Use STATIC type for argv/environ strings.
+	* Makefile.am: Corresponding changes.
+	* Makefile.in: Regenerated.
+
+2003-06-11  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-heuristics.c (__mf_heuristic_check): Disable stack_bounds
+	heuristic for threaded case, and for non-x86-linux targets.
+	* mf-hooks.c (__mf_0fn_calloc): Provide a working dummy implementation
+	for use during pre-main() program startup.
+	(__mf_0fn_*): Make these functions non-static.
+	* mf-impl.h (DECLARE, CALL_REAL): Support calls to 0fn backup hook
+	functions.
+	* mf-runtime.c (__mf_state): Set initial state to "starting".
+	(__mf_resolve_single_dynamic): Tolerate repeated calls for same symbol.
+	(__wrap_main): New function to register argv[] and environ[] strings.
+	(__mf_ini): Call it.
+	(*): In all trace functions, use "%p" as formatter for uintptr_t.
+
+	* testsuite/libmudflap.c/pass38-frag.c: New test case.
+	* testsuite/libmudflap.cth/pass37-frag.c: Improved test.
+
+	* acinclude.m4: Add comments with aoliva's concerns about x86_64
+	pass_all.
+	* aclocal.m4, configure: Regenerated.
+
+2003-06-04  Frank Ch. Eigler  <fche at redhat.com>
+
+	* acinclude.m4: Correct typo in AC_MSG_CHECKING.
+	* aclocal.m4, configure: Regenerated.
+
+2003-06-03  Frank Ch. Eigler  <fche at redhat.com>
+
+	* acinclude.m4: Force "pass_all" deplibs_check_method for libtool
+	for x86_64 target.  Disable caching for this value.
+	* aclocal.m4, configure: Regenerated.
+
+2003-06-02  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/pass38-frag.c: Deleted.  -fwritable-strings
+	is about to become deprecated, and its present handling bugs are
+	unworthy of fixing.
+
+2003-05-30  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/pass38-frag.c: New test for
+	-fwritable-strings.
+
+2003-05-23  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (__mf_sigusr1_handle): Call unlocked variant of
+	__mf_report, asserting reentrant calling context.
+
+2003-05-23  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (realloc): Correct reentrancy logic.
+	* testsuite/libmudflap.c/hook-allocstuff.c: New test case.
+
+2003-05-20  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (LIBMUDFLAPTH_THREADS_MAX): New macro, replaces
+	PTHREAD_THREADS_MAX.  Update users.
+	* mf-runtime.c (__mf_usage): Print [active] instead of [default]
+	for active options.
+	* testsuite/Makefile.am (all-local): Prime dejagnu site.exp file
+	with libmudflapth presence indicator.
+	* testsuite/Makefile.in: Regenerated.
+
+2003-05-16  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am (AM_CFLAGS): Remove "-ansi".
+	* configure.in: Remove silly no-pthreads => no-shared logic.
+	* Makefile.in, configure: Regenerated.
+	* mf-heuristics.c (__mf_heuristic_check): Remove reentrancy hacks.
+	* mf-hooks.c (BEGIN_PROTECT, END_PROTECT): Reorganize reentrancy
+	code.  Count reentrancy events.
+	(all hook functions): Don't directly manipulate __mf_state variable.
+	Add TRACE calls to hook functions without them.
+	* mf-impl.h (LOCKTH): Try to count lock contention events.
+	(VERBOSE_TRACE, TRACE): Remove reentrancy hacks.
+	* mf-runtime.c (BEGIN_RECURSION_PROTECT, END_RECURSION_PROTECT):
+	Reorganize reentrancy code.
+	(external __mf_ entry points): Use RECURSION_PROTECT mechanism to
+	identify reentrancy with mutex holding times.
+	(internal __mfu_ entry points): Remove internal reentrancy code.
+	(__mf_init): Use ordinary locked calls.
+	(__mfu_report): Print the two new counts.
+	* testsuite/lib/libmudflap.exp:	Filter out junk ld/pthreads messages.
+	* testsuite/libmudfap.cth/cthfrags.exp: New test driver.
+	* testsuite/libmudflap.cth/pass37-frag.c: New pthreads test.
+	* testsuite/libmudfap.cth/cfrags.exp: Adapt to new libmudflap
+	option defaults.
+
+2003-05-09  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.in: Add pthread support, plus glibc and porting hacks.
+	* Makefile.am (LIBMUDFLAPTH): New conditional, to build -lmudflapth
+	from objects built into ./pth/.
+	* mf-runtime.c (__mfu_watch,register,...): Fork new unlocked
+	functions for internal entry points.  Update callers to pick
+	locked vs. unlocked variants.
+	(__mf_resolve_single_dynamic): Extend to support symbol versioning
+	info coming in from a static data structure.
+	(*): Reorder miscellaneous declarations to group data vs functions.
+	(__mf_set_default_options): Simplify.
+	(__mf_usage): Mention threading status of host executable.
+	* mf-impl.h: Move max/min decls here.  Reorganize __mf_dynamic
+	decls to match above.
+	(LOCKTH, UNLOCKTH): New macros for Big Libmudflap Lock management.
+	* mf-heuristics.c: Choose between locked/unlocked calls.  Add
+	some lock/unlock markers.  Remove some unused code.
+	* mf-hooks: Ditto.
+	(pthread_create): New hook function.
+	(__mf_pthread_cleanup, _spawner): New helper functions.
+	* configure. aclocal.m4, config.h.in, Makefile.in: Regenerated.
+
+2003-05-02  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/fail27-frag.c: Add more volatile flags.
+
+2002-04-28  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am (HOOKOBJS): Add *time related hooks.
+	* configure.in: Look for pthreads.h header.
+	* mf-hooks.c (asctime, ctime, gmtime, localtime): New wrappers.
+	* mf-runtime.c: Begin sketching some pthreads support.
+	(__mf_usage): Check for -lpthread presence.
+	(__mf_unregister): Confirm matching unregistration base.
+	(__mf_find_objects_rec): Reduce unnecessary recursion.
+	* mf-runtime.h.in: Add "nothrow" attribute to functions.  Add
+	#defines for new hook functions.
+	* mf-impl.h: Corresponding changes.
+	* config.h.in, configure, Makefile.in: Regenerated.
+
+2002-04-27  Diego Novillo  <dnovillo at redhat.com>
+
+	* testsuite/libmudflap.c/fail1-frag.c: Add volatile
+	modifiers to prevent being optimized away.
+	* testsuite/libmudflap.c/fail10-frag.c: Likewise.
+	* testsuite/libmudflap.c/fail13-frag.c: Likewise.
+	* testsuite/libmudflap.c/fail14-frag.c: Likewise.
+	* testsuite/libmudflap.c/fail15-frag.c: Likewise.
+	* testsuite/libmudflap.c/fail2-frag.c: Likewise.
+	* testsuite/libmudflap.c/fail20-frag.c: Likewise.
+	* testsuite/libmudflap.c/fail3-frag.c: Likewise.
+
+2003-04-15  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am (libmudflap_la_LIBADD): Remove -ldl.
+	* configure.in: Look for uintptr_t and -ldl on target.
+	* mf-runtime.h.in: Adjust uintptr_t declaration logic.
+	* Makefile.in, aclocal.m4, configure, config.h.in: Regenerated.
+	* testsuite/Makefile.in: Regenerated.
+	* mf-runtime.c (__mf_sigusr1_respond): Tweak declaration and calls
+	for better C compliance.
+
+2003-04-15  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (MF_VALIDATE_EXTENT): Remove unnecessary reentrancy
+	prevention code.
+	* mf-runtime.c (__mf_set_default_options): Turn off
+	check-initialization.
+	(__mf_describe_object): Shorten description.
+	* testsuite/libmudflap.c/fail25-frag.c: Turn on check-initialization.
+
+2003-04-07  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (__mf_0fn_mmap): Correct return value, as per <rth>.
+
+2003-04-02  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (BEGIN_PROTECT): Handle startup-time reentrant
+	calls specially.
+	(__mf_0fn_malloc ... _munmap): New dummy backup calls.
+	* mf-impl.h (CALL_BACKUP): New macros.
+	* mf-runtime.c (__mf_init): Tweak __mf_state during startup.
+
+2003-03-31  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am (AM_CFLAGS): Remove optimization flags.
+	(HOOKOBJS): Remove dlopen hook.
+	(libmudflap_la_LIBADD): Add -ldl.
+	* mf-hooks.c (dlopen): Remove hook.
+	* mf-impl.h (__mf_dynamic): Ditto.
+	* mf-runtime.c (__mf_resolve_dynamics): Ditto.
+	* Makefile.in: Regenerated.
+
+2003-03-28  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.in: Check for target gettimeofday, signal, some headers.
+	* mf-impl.h (__mf_opts): Add new "sigusr1_report" field.  Comment
+	out inop multi_threaded field.
+	* mf-runtime.c (options): Handle new "-sigusr1-report" option.
+	(__mf_set_options): Correct handling of "-help".
+	(__mf_sigusr1_respond): New function to manage SIGUSR1 response.
+	(__mf_check, __mf_register, __mf_unregister): Call it.
+	(__mf_insert_new_object, __mf_unregister): Respect HAVE_GETTIMEOFDAY.
+	(__mf_report_leaks): Make callable
+	(__mf_tree_analyze): Traverse in-order.  Accumulate address bit
+	distribution statistics.
+	(__mf_adapt_cache): Rewrite shift guessing logic based on address
+	bit distributions.
+	* config.h.in, configure: Regenerated.
+	* testsuite/libmudflap.c/fail27-frag.c: New test.
+	* testsuite/libmudflap.c/pass36-frag.c: New test.
+
+2003-03-11  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.h.in: Tweak.
+	* Makefile.am, configure.in: Tweak mf-runtime.h generation some more.
+	Don't use intermediate files nor AC_OUTPUT-time postprocessing.
+	* Makefile.in, testsuite/Makefile.in, configure: Regenerated.
+
+2003-03-10  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.in: Tweak generation of mf-runtime.h some more.  It
+	needs to work from both config.status and configure.
+	* configure: Regenerated.
+
+2003-03-10  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am: Reorganize hook file building.  Add auto dependencies.
+	* configure.in: Tweak generation of mf-runtime.h.
+	* mf-runtime.h.in: Add new __MF_TYPE_HEAP_I.
+	* mf-hooks.c (*): Adapt to initialized-heap object type.
+	* mf-impl.h: Tweak cemetary boundaries.
+	* mf-runtime.c (__mf_check): Adapt to new initialized-heap object
+	type.
+	(__mf_insert_new_object, __mf_register, __mf_unregister): Ditto.
+	(__mf_describe_object, __mf_report_leaks, __mf_violation): Ditto.
+	* testsuite/lib/libmudflap.exp (includes): Include build tree.
+	* testsuite/libmudflap.c/pass{26,5}: Further adapt to initialization
+	checking.
+	* testsuite/.../fail{25,26}-frag.c: New tests.
+	* testsuite/.../pass{32,33,34,35}-frag.c: New tests.
+	* Makefile.in, configure: Regenerated.
+
+2003-03-05  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (__mf_set_default_options): Turn on initialization
+	checking by default.
+	(__mf_insert_new_object): As a temporary hack, assume that new
+	objects registered on the stack start out initialized.
+	* testsuite/libmudflap.c/fail9,pass23,pass[6789]-*: Initialize
+	heap objects by hand.
+
+2003-03-05  Frank Ch. Eigler  <fche at redhat.com>
+
+	Switch to macro-style hooks for str*/mem*/b* functions.
+	* mf-runtime.h.in (__MF_TYPE_*): Moved some internal values out.
+	(mem*, str*, b*): Added macro-style hooks for _MUDFLAP case.
+	* mf-runtime.c: #include config.h to enable glibc backtraces again.
+	(__mf_set_default_options): Turn off heur_proc_map.
+	(*): Adapt to to macro-style hook functions.
+	(__mf_object_dead_head, __mf_object_cemetary): Correct bounds.
+	(__mf_check, __mf_register, __mf_unregister): Tweak tracing message.
+	(__mf_violation): Handle __MF_VIOL_WATCH.
+	* mf-impl.h (__MF_TYPE_*): Moved these internal values here.
+	(__mf_dynamic): Removed mem*/str*/b* functions.
+	(TRACE, VERBOSE_TRACE): Add reentrancy locking.
+	(WRAPPER2): New macro for macro-style hooks.
+	* mf-hooks.c: Convert mem*/str*/b* functions to simpler
+	macro-style hooks.
+	(BEGIN_PROTECT): Tweak tracing vs reentrancy-lock ordering.
+	* mf-heuristics.c: Adapt to macro-style hook functions.
+	Correct some comments.
+	* testsuite/lib/mfdg.exp (dg-test): Simplify result string for
+	output pattern tests.
+	* testsuite/libmudflap.c/fail[89]-frag.c: Elaborate output test.
+	* testsuite/libmudflap.c++/c++frags.exp: Enable non-static tests.
+
+2003-02-28  Frank Ch. Eigler  <fche at redhat.com>
+
+	* testsuite/libmudflap.c/fail23-frag.c, pass30-frag.c: New tests
+	for global array registration.
+	* testsuite/libmudflap.c++/fail24-frag.cxx, pass31-frag.cxx: Ditto.
+	* testsuite/libmudflap.c++/c++frags.exp: Tweak -static multilib hack.
+
+2003-02-27  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am: Add gross make bug workarounds.  Tweaked
+	SUBDIRS and AM_CFLAGS.
+	* Makefile.in: Regenerated.
+
+2003-02-26  Frank Ch. Eigler  <fche at redhat.com>
+
+	Switch to dejagnu.
+	* configure.in (AC_PROG_CXX): Don't look for C++ any more.
+	* Makefile.am (TESTS): Remove simple automake testing.
+	* configure, Makefile.in: Regenerated.
+	(SUBDIRS): Include new testsuite/ directory.
+	* tests/*: Removed all files; moved bulk under:
+	* testsuite/*: New subdirectory tree.
+	* testsuite/libmudflap.c/cfrags.exp: New file, C test driver.
+	* testsuite/libmudflap.c++/c++frags.exp: New file, C++ test driver.
+	* testsuite/lib/libmudflap.exp: New file, derived from libstdc++.
+	* testsuite/lib/mfdg.exp: New file, derived from dejagnu.
+	* testsuite/config/default.exp: New file.
+	* testsuite/Makefile.am, Makefile.in: New files.
+
+2003-01-29  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am (TESTS_ENVIRONMENT): Remove redundant "-mode-check".
+	(TESTS): Add fail22 and pass29 tests.
+	* mf-runtime.h.in: Change API to take void*/size_t region parameters.
+	Add new access-type parameter for __mf_check.  Move __MF_VIOL* out.
+	* mf-impl.h: Corresponding changes.  Update CLAMP* macros for void*
+	values.  Move __MF_VIOL* here.
+	* mf-runtime.c (*): Adapt to void*/size_t API in mf-runtime.h.
+	(check_initialization): New field in __mf_opts.  Default off.
+	(read_count,write_count): New fields in __mf_object.
+	(__mf_check): Implement basic initialization checking.
+	(__mf_insert_new_object): Assume STATIC|GUESS regions are initialized.
+	(__mf_describe_object): Print new fields.
+	(__mf_violation): Identify check/read vs. check/write in messages.
+	* test/pass29-frag.c, test/fail22-frag.c: Basic tests for new
+	"-check-initialized" mudflap option.
+	* test/pass25-frag.c, test/fail21-frag.c: Adapt to API changes.
+	* mf-hooks.c (MF_VALIDATE_EXTENT): Add new access-type parameter.
+	Drop __FILE__/__LINE__ hack.  Update callers.
+	(*): Adapt to new mf-runtime.h API.
+	* Makefile.in: regenerated.
+
+2003-01-24  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.in: Build mf-runtime.h a more proper way.
+	* mf-hooks.c (strdup, strndup): Correct reentrancy logic.
+	* mf-runtime.c (verbose_violations): Turn on by default.
+	* mf-runtime.h.in: Remove some miscellaneous stuff ...
+	* mf-impl.h: ... and move it here.
+	* configure: Regenerated.
+
+2003-01-22  Frank Ch. Eigler  <fche at redhat.com>
+
+	* configure.in: Look for C++ compiler.
+	* test/*-frag.c, mf-driver.c: Reformatted with GNU indent and
+	fixed type warnings when built with C++.
+	* test/pass27-frag.cxx, pass28-frag.cxx: New C++ tests.
+	* Makefile.am (TESTS): Run them.
+	(*) Add new rules for building and running C++ tests.
+	(TESTFLAGS): Set new default to avoid libstdc++-v3 shlib issues.
+	* mf-runtime.h.in: Protect with extern "C".
+	* Makefile, configure: Regenerated.
+
+2003-01-06  Frank Ch. Eigler  <fche at redhat.com>
+
+	Portability improvements.
+	* configure.in: Look for glibc backtrace headers/functions.
+	* mf-hooks.c: Don't include <execinfo.h> any more.
+	* mf-runtime.c (__mf_set_options): Call more stdlib functions
+	via CALL_REAL.
+	(__mf_backtrace): Provide alternate baby implementation in
+	absence of glibc.
+	* test/mf-driver.c: Portability tweaks.
+	* acinclude.m4: New file, containing top level libtool.m4.
+	* aclocal.m4, configure, Makefile.in, config.h.in: Regenerated.
+
+2002-12-19  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.h.in (HAVE_UINTPTR_T): Define unconditionally.
+
+2002-11-08  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (options): Add new "wipe-heap", "wipe-stack"
+	options.
+	(__mf_unregister): Implement stack/heap object wiping.
+	(__mf_set_options): Renamed from __mf_process_opts.
+	(__mf_uncache_object): Change arg type, correct callers.
+	* mf-impl.h: Corresponding changes.
+	* mf-hooks.c (realloc): Save/restore heap-wiping flag.
+	* mf-runtime.h.in (__mf_set_options): Extend public API.
+	* test/pass26-frag.c: New test for stack wiping.
+	* Makefile.am (TESTS): Run it.
+	* Makefile.in: Regenerated.
+
+2002-11-07  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.h.in (__mf_watch, __mf_unwatch): Extend public API.
+	* mf-runtime.c (__mf_object_t): Add watching_p field.
+	(__mf_watch_or_not): New function to implement
+	object watch flagging.
+	(__mf_watch, __mf_unwatch): New wrappers for above.
+	(__mf_check, __mf_describe_object): Handle objects with watching_p.
+	(__mf_count_violation): Enlarge array.
+	(__mf_uncache_object): Renamed from __mf_remove_old_object.  Don't
+	unlink object.  Clear cache properly.
+	(__mf_unregister): Unlink object explicitly before uncaching.
+	* test/fail21-frag.c, pass25-frag.c: New tests.
+	* Makefile.in, aclocal.m4: Regenerated.
+
+2002-11-05  Frank Ch. Eigler  <fche at redhat.com>
+
+	* test/fail20-frag.c: New test for NULL pointer dereferencing.
+	* Makefile.am (TESTS): Add it.
+	* test/pass-stratcliff.c: Add decls of stpcpy.
+	* configure.in: Test for <stdint.h>.  Generate mf-runtime.h in
+	build tree from config.h and new file mf-runtime.h.in.
+	* mf-runtime.h.in: Renamed from mf-runtime.h.  Tweak uintptr_t decl.
+	* Makefile.in, configure, config.h.in: Regenerated.
+	* mf-hooks.c: Add #undef for wrapped glibc str*/mem* macros.
+	* mf-runtime.c (options, __mf_set_default_options): Support new
+	default "abbreviate" option.
+	(__mf_object.description_epoch): New field.
+	(__mf_describe_object): Conditionally abbreviate objects already
+	displayed in current epoch.  Accept NULL input to increment epoch.
+	(__mf_fini, __mf_ini): Reset description epoch.
+	(__mf_register, __mf_unregister, __mf_adapt_cache, __mf_init): Ensure
+	that NULL pointer slot in lookup cache is invalidated.  Register a
+	NOACCESS region around NULL.
+	* mf-impl.h: Corresponding changes.
+
+2002-10-16  Frank Ch. Eigler  <fche at redhat.com>
+
+	* test/fail19-frag.c, pass24-frag.c, pass-stratcliff.c: New tests.
+	* Makefile.am: Run them.  Install mf-runtime.h.
+	* Makefile.in: Regenerated.
+	* mf-hooks.c: Add some markers for more missing functions.
+	* mf-runtime.c (__mf_adapt_cache): Experiment with a utilization-based
+	statistic to tune tune cache size (mask).
+
+2002-10-01  Frank Ch. Eigler  <fche at redhat.com>
+
+	* test/pass23-frag.c: New test for bit_field_ref expressions.
+	* Makefile.am, Makefile.in: Add new test.
+	* mf-hooks.c (mmap, munmap): Rewrite to track individual pages.
+	(MF_VALIDATE_EXTENT): Accept zero-size mem/str operations.
+	* mf-runtime.c (__mf_init): Register errno global.
+	(__mf_find_object): Removed function.
+	(__mf_check): Rewrite logic to support accesses across some
+	contiguous but distinctly registered objects.
+	(__mf_remove_old_object): Tolerate cache entries that span
+	contiguous objects.
+
+2002-09-30  Frank Ch. Eigler  <fche at redhat.com>
+
+	* test/pass21-frag.c, pass22-frag.c: New tests: alloca, bitfields.
+	* Makefile.am, Makefile.in: Run new tests.
+	* mf-hooks.c (alloca): Correct stack direction logic.
+
+2002-09-26  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-impl.h (adapt_cache): New option.
+	* mf-runtime.c (__mf_set_default_options): Set its default value.
+	Tweak the tree_aging parameter down.
+	(__mf_check): Maintain separate counter for cache-adaptation.
+	(__mf_tree_analyze): New function to collect object tree stats.
+	(__mf_adapt_cache): New function to automate cache parameters.
+
+2002-09-24  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-heuristics.c (__init_misc, __mf_heuristic_check): Add
+	hypothetical #if-0'd argv/envp region registration.
+	* mf-runtime.c (__mf_init): Add kludged form of above.
+	(*) Add "heur_argv_environ" flag, default on, to govern this.
+	* mf-impl.h: Corresponding changes.
+
+2002-09-20  Frank Ch. Eigler  <fche at redhat.com>
+
+	* test/fail18-frag.c: New test file for NOACCESS regions.
+	* Makefile.am (TESTS): Add new test.
+	* Makefile.in: Regenerated.
+
+	* mf-heuristics.c (__mf_heuristics_check): Correct deja_vu logic.
+	* mf-impl.h (tree_aging): Add new mudflap_option, default 1000000.
+	(optimize_object_tree): Remove unused mudflap_option.
+	* mf-runtime.h (__MF_TYPE_NOACCESS): New region type.  Add printing
+	support throughout.  Use .._MAX_CEM for cemetary upper bound.
+	* mf-runtime.c (__mf_init): Register __mf_* globals as NOACCESS
+	regions.
+	(__mf_object): Add new liveness field for use by tree aging.
+	(__mf_check): Trigger tree aging when needed.
+	(__mf_age_tree): New function to decay liveness field.
+	(__mf_find_objects_rec): Use liveness field to rotate tree.
+	(__mf_insert_new_object): Only provide backtrace for HEAP objects.
+	(__mf_unregister): Ditto.
+	(__mf_register): Tweak duplicate-static message.
+	(__mf_violation: Tweak nearby-object counter printing.
+
+2002-09-16  Frank Ch. Eigler  <fche at redhat.com>
+
+	* test/pass20-frag.c: New test file.
+	* Makefile.am (TESTS): Reorganize.  Add pass20 test.
+	* Makefile.in: Regenerated.
+
+	* mf-impl.h (TRACE_IN, TRACE_OUT): Remove macros.  Update callers.
+	* mf-hooks.c (BEGIN_PROTECT): Add hook tracing here.
+	* mf-heuristic.c (__mf_heuristic_check): Track seen /proc/self/map
+	entries to avoid repeat registration.
+	* mf-runtime.c (__mf_object_cemetary): Don't bother bury GUESS regions.
+	(__mf_register, __mf_unregister): Rewrite GUESS handling logic.
+
+2002-09-09  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am: Create test sources with #include, not cat>>.
+	* Makefile.in: Regenerated.
+	* test/buildtest.sh: Removed.
+	* test/driver.c (abort_handler, main): Be quiet.
+
+2002-09-06  Frank Ch. Eigler  <fche at redhat.com>
+
+	* test/pass18-frag.c, pass19-frag.c: New tests.
+	* Makefile.am (check): Run them.  Rebuild test programs each time.
+	* Makefile.in: Regenerated.
+
+2002-09-06  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (__mf_register): Correct SEGV-inducing error in
+	overlapping object search.
+	(__mf_violation): Likewise for nearby objects.
+	Improve nearby-object listing.
+
+	cleanup:
+	* mf-runtime.c, mf-hooks.c: Remove "{{{"/"}}}" folding marks.
+	* mf-heuristics.c (__mf_heuristic_check): Tweak message.
+
+2002-09-03  Frank Ch. Eigler  <fche at redhat.com>
+
+	alloca support:
+	* Makefile.am (AM_CFLAGS): New definition of needed settings.
+	(HOOKOBJS): Add alloca-hook.o.
+	* mf-hooks.c (alloca): New function to implement alloca in libiberty
+	style.
+	* mf-runtime.c (__mf_report): Call alloca(0) to flush remaining blocks.
+	(__mf_backtrace): Reimplement without using alloca.
+	* Makefile.in: Regenerated.
+
+	cleanup:
+	* mf-hooks.c: Use VERBOSE_TRACE throughout instead of fprintf(stderr).
+	Correct signedness bugs in length-tracking variables.
+	* mf-impl.h: Make options unsigned.
+	(CALL_WRAP): New macro to parallel CALL_REAL().
+	(DECLARE): Remove erroneous ";" at end.
+	* mf-runtime.c, mf-hooks.c, mf-heuristics.c: Replace remaining %p
+	formatting specs with %08lx.  Correct several compiler warnings.
+
+2002-08-28  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-runtime.c (__mf_violation): Try harder to locate nearby objects.
+
+2002-08-27  Frank Ch. Eigler  <fche at redhat.com>
+
+	libmudflap hook breakup:
+	* Makefile.am (TESTS_ENVIRONMENT): Add ../../gcc to LD_LIBRARY_PATH
+	for libgcc_s.
+	(TESTS): Make dependent on libmudflap.
+	(HOOKOBJS): Break up mf-hooks.o into many little hook objects,
+	compiled from segments of mf-hooks.c.
+	* mf-hooks.c: Corresponding changes: wrap each function in
+	#ifdef/#endif.
+	* Makefile.in: Regenerated.
+
+	Heuristics reorganization:
+	* mf-heuristics.c (__mf_register_ro_sections, __mf_init_heuristics):
+	Remove these functions.  Update callers.
+	(__mf_heuristic_check): Incorporate all the various heuristics.
+	Encode cacheability/retry judgement into trinary return value.
+	Separate start-end logic into a separate fallback heuristic.  Only
+	register relevant /proc/self/map segments.
+	* mf-impl.h: Corresponding changes.
+	* mf-runtime.c (__mf_check): Reorganize heuristics fallback logic.
+	(__mf_init): Don't call __mf_init_heuristics.
+
+	Tracing cleanup:
+	* mf-heuristics.c, mf-runtime.c: Use new MUDFLAP_OPTION
+	"-verbose-trace" to emit all tracing messages other than those of
+	basic public api.  Eliminate some duplicate/excessive messages.
+	* mf-runtime.h: Corresponding changes.
+
+2002-08-27  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-impl.h (WRAPPER): Change to create linker aliases for __wrap
+	and __real when compiled with -DPIC.
+	* mf-hooks.c (WRAPPER): Change all uses of WRAPPER macro slightly.
+	* Makefile.am (AUTOMAKE_OPTIONS): Fix LD_LIBRARY_PATH for tests.
+	* Makefile.in: Regenerate.
+
+2002-08-26  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-impl.h: New file, private implementation header.
+	* mf-runtime.h: Reorganize a bit.
+	(CLAMPSZ): Fix arithmetic.
+	(__MF_CACHE_MISS_P): Fix arithmetic.
+	* mf-runtime.c: Reorganize a bit.
+	(__mf_dynamic): New structure.
+	(resolve_single_dynamic): New function.
+	(__mf_resolve_dynamics): New function.
+	(__mf_init): Initialize dynamic wrappers.
+	* mf-hooks.c: Macro-ize __real calls.
+	Clamp various bits of arithmetic.
+	Add explicit __mf_check call contexts.
+	* Makefile.am: Add dependencies on mf-impl.h
+	* Makefile.in: Regenerate.
+	* configure.in: Comment out shared override.
+	* configure: Regenerate.
+
+2002-08-22  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-runtime.c (__mf_process_opts): Sanity-check free_queue_length.
+	(__mf_check): Re-inialize and check heuristics before violation.
+	(__mf_register): Permit updating pure-guess regions.
+	* mf-hooks.c (__wrap_free): Correct some free queue logic.
+	(__wrap_dlopen): New wrapper function.
+	(__wrap_mmap): New wrapper function.
+	(__wrap_munmap): New wrapper function.
+	* mf-heuristics.c (__mf_register_ro_sections): Register *all* regions
+	which are not stack addresses.
+	(is_stack_address): New function.
+	(__mf_init_heuristics): Save and restore state, always initialize with
+	"starting" state.
+
+2002-08-21  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c (MF_VALIDATE_EXTENT): Rewrite to correct off-by-one
+	error.  Pass location string.
+	(wrap_strcpy, wrap_strncpy): Remove extra %s in trace strings.
+	* mf-runtime.c (options): Add lc-mask, lc-shift options.
+	(__mf_process_opts): Apply some sanity checking for lc-mask.
+	(__mf_check, __mf_violation): Take new location-string argument.
+	Update callers to pass NULL if necessary.
+	(__mf_backtrace): New smart backtracer function.  Calls replace
+	several ad-hoc blocks elsewhere.
+	(__mf_describe_object): Remove bad reentrancy test.  Improve
+	tracing message.
+	* mf-runtime.h: Corresponding changes.  Public/private markup.
+	(__MF_CACHE_MISS_P): New macro.
+
+2002-08-20  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-runtime.h: New option: stack_bound (heuristic).
+	Move some macros out of implementation files.
+	* mf-runtime.c: New option string: -stack-bound.
+	Unify recursion protection with hooks.
+	Add more logging.
+	(__mf_check): Call __mf_heuristic_check.
+	(__mf_process_opts): Fix "no-" processing.
+	* mf-heuristics.c (__mf_heuristic_check): New function.
+	* mf-hooks.c: Much off-by-one fixing, recursion protection.
+
+2002-08-20  Frank Ch. Eigler  <fche at redhat.com>
+
+	Option parsing improvements, region splitting bug fixes:
+	* mf-heuristics.c (__mf_register_ro_sections): Add warned casts.
+	* mf-runtime.h (heur_proc_map): New libmudflap option.
+	* mf-runtime.c (__mf_set_default_options): Set it.
+	(__mf_usage): Print default values/status.
+	(__mf_process_opts): Support general "no-" option string prefix.
+	(__mf_init): Print __mf_usage on unknown-option error.
+	(__mf_register): Print trace message up front.
+	Correct region splitting logic for case where a subregion disappears.
+	Correct memory leak.
+	(__mf_violation): Make even basic message conditional on option.
+
+	Build cleanup:
+	* Makefile.am (TESTS_ENVIRONMENT): Add -no-heur-proc-map.
+	(clean-local): New target.
+	(test/*x rules): Add -g CFLAGS.
+	(CFLAGS): Add -freorder-blocks.
+	(MFCONFIG_CFLAGS, INCLUDE): Remove unneeded settings.
+	* Makefile.in: Regenerated.
+	* Makefile, mf-config.h: Removed files.
+
+2002-08-16  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-runtime.c (__mf_insert_new_object): Factor out of
+	__mf_register.
+	(__mf_remove_old_object): Factor out of __mf_unregister.
+	(__mf_register): Handle guessed regions, splitting
+	guesses when new registrations arrive.
+	(__mf_unregister): Do not unregister guesses.
+	* mf-runtime.h: Move convenience macros around,
+	declare new option fields. Add __MF_TYPE_GUESS.
+	* mf-hooks.c (__wrap_*alloc): Use crumple zones.
+	(__wrap_free): Call __real_free for deferred frees.
+	* Makefile.am: Add more tests, fix dependency.
+	* Makefile.in: Regenerate.
+	* test/pass[13..17]-frag.c: New testcases.
+	* test/fail[13..17]-frag.c: New testcases.
+
+2002-08-15  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-heuristics.c: New file.
+	* mf-runtime.c (options): Add -trace-calls option.
+	(__mf_init): Call __mf_init_heuristics.
+
+2002-08-14  Graydon Hoare  <graydon at redhat.com>
+
+	* Makefile.am (TESTS): Add testsuite support.
+	* Makefile.in: Regenerate.
+	* test/mf-driver.c: New file.
+	* test/buildtest.sh: New file.
+	* test/passNN-frag.c: New testcases.
+	* test/failNN-frag.c: New testcases.
+
+2002-08-14  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-hooks.c: Change __real_strlen() to __real_strlen()+1 when
+	verifying non-size-limited string extents.
+
+2002-08-14  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c: Make __wrap string* functions use __real_str[n]len
+	instead of plain str[n]len for internal checks.
+	* mf-runtime.c (__mf_violation): Print optional stack traceback.
+
+2002-08-14  Frank Ch. Eigler  <fche at redhat.com>
+
+	* mf-hooks.c: Remove #if-0 around hooks that are now ld-wrapped.
+
+2002-08-13  Graydon Hoare  <graydon at redhat.com>
+
+	* mf-runtime.c: Rework configuration to operate on
+	environment variable options rather than #defines
+	(__mf_violation): Add simple fork-a-gdb violaiton mode.
+	(__mf_init): Set static __mf_active_p flag on startup,
+	to inhibit mudflap wrap-based checking during crt0.s.
+	* mf-runtime.h: Declare options structure.
+	* mf-hooks.c: New wrappings for mem*, b*, str*
+	libc functions (temporarily #if 0-ed out).
+
+2002-08-12  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile.am, configure.in: New files.
+	* Makefile.in, Makefile, configure, config.h.in: New generated files.
+	* stamp-h.in, aclocal.m4: Ditto.
+
+2002-08-08  Frank Ch. Eigler  <fche at redhat.com>
+
+	* Makefile: New file.
+	* mf-config.h: New file: runtime configuration.
+	* mf-hooks.c: New file: interposed libc functions.
+	* mf-runtime.c: New file: bulk of runtime.
+	* mf-runtime.h: New file: public functions.

Added: llvm-gcc-4.2/trunk/libmudflap/Makefile.am
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/Makefile.am?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/Makefile.am (added)
+++ llvm-gcc-4.2/trunk/libmudflap/Makefile.am Thu Nov  8 16:56:19 2007
@@ -0,0 +1,115 @@
+## Makefile for the toplevel directory of the mudflap library.
+##
+## Copyright (C) 2002, 2003, 2004
+## Free Software Foundation, Inc.
+##
+
+AUTOMAKE_OPTIONS = 1.8 foreign
+ACLOCAL_AMFLAGS = -I .. -I ../config
+MAINT_CHARSET = latin1
+SUBDIRS = testsuite
+
+# May be used by various substitution variables.
+gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER)
+
+SECTION_FLAGS = @SECTION_FLAGS@
+AM_CFLAGS = -Wall $(SECTION_FLAGS)
+
+if LIBMUDFLAPTH
+libmudflapth = libmudflapth.la
+else
+libmudflapth =
+endif
+
+toolexeclib_LTLIBRARIES = libmudflap.la $(libmudflapth)
+target_noncanonical = @target_noncanonical@
+libsubincludedir = $(libdir)/gcc/$(target_noncanonical)/$(gcc_version)/include
+nobase_libsubinclude_HEADERS = mf-runtime.h
+
+
+libmudflap_la_SOURCES = \
+	mf-runtime.c \
+	mf-heuristics.c \
+	mf-hooks1.c \
+	mf-hooks2.c
+libmudflap_la_LIBADD = 
+libmudflap_la_DEPENDENCIES = $(libmudflap_la_LIBADD)
+libmudflap_la_LDFLAGS = -version-info `grep -v '^\#' $(srcdir)/libtool-version`
+
+clean-local:
+	rm -f pth/*.o pth/*.lo
+
+pth/mf-runtime.lo: mf-runtime.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-runtime.c -o $@
+pth/mf-heuristics.lo: mf-heuristics.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-heuristics.c -o $@
+pth/mf-hooks1.lo: mf-hooks1.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-hooks1.c -o $@
+pth/mf-hooks2.lo: mf-hooks2.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-hooks2.c -o $@
+pth/mf-hooks3.lo: mf-hooks3.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-hooks3.c -o $@
+
+
+libmudflapth_la_SOURCES =
+libmudflapth_la_LIBADD = \
+	pth/mf-runtime.lo \
+	pth/mf-heuristics.lo \
+	pth/mf-hooks1.lo \
+	pth/mf-hooks2.lo \
+	pth/mf-hooks3.lo
+libmudflapth_la_DEPENDENCIES = $(libmudflapth_la_LIBADD)
+libmudflapth_la_LDFLAGS = -version-info `grep -v '^\#' $(srcdir)/libtool-version`
+
+
+# XXX hack alert
+# From libffi/Makefile.am
+
+# Work around what appears to be a GNU make bug handling MAKEFLAGS
+# values defined in terms of make variables, as is the case for CC and
+# friends when we are called from the top level Makefile.
+AM_MAKEFLAGS = \
+	"AR_FLAGS=$(AR_FLAGS)" \
+	"CC_FOR_BUILD=$(CC_FOR_BUILD)" \
+	"CFLAGS=$(CFLAGS)" \
+	"CXXFLAGS=$(CXXFLAGS)" \
+	"CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \
+	"CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \
+	"INSTALL=$(INSTALL)" \
+	"INSTALL_DATA=$(INSTALL_DATA)" \
+	"INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
+	"INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \
+	"JC1FLAGS=$(JC1FLAGS)" \
+	"LDFLAGS=$(LDFLAGS)" \
+	"LIBCFLAGS=$(LIBCFLAGS)" \
+	"LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \
+	"MAKE=$(MAKE)" \
+	"MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \
+	"PICFLAG=$(PICFLAG)" \
+	"PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \
+	"SHELL=$(SHELL)" \
+	"RUNTESTFLAGS=$(RUNTESTFLAGS)" \
+	"exec_prefix=$(exec_prefix)" \
+	"infodir=$(infodir)" \
+	"libdir=$(libdir)" \
+	"prefix=$(prefix)" \
+	"includedir=$(includedir)" \
+	"AR=$(AR)" \
+	"AS=$(AS)" \
+	"CC=$(CC)" \
+	"CXX=$(CXX)" \
+	"LD=$(LD)" \
+	"LIBCFLAGS=$(LIBCFLAGS)" \
+	"NM=$(NM)" \
+	"PICFLAG=$(PICFLAG)" \
+	"RANLIB=$(RANLIB)" \
+	"DESTDIR=$(DESTDIR)"
+
+MAKEOVERRIDES=
+
+.PHONY: install-html
+
+install-html:
+
+## ################################################################
+

Added: llvm-gcc-4.2/trunk/libmudflap/Makefile.in
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/Makefile.in?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/Makefile.in (added)
+++ llvm-gcc-4.2/trunk/libmudflap/Makefile.in Thu Nov  8 16:56:19 2007
@@ -0,0 +1,870 @@
+# Makefile.in generated by automake 1.9.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+ at SET_MAKE@
+
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = .
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+DIST_COMMON = $(am__configure_deps) $(nobase_libsubinclude_HEADERS) \
+	$(srcdir)/../config.guess $(srcdir)/../config.sub \
+	$(srcdir)/../depcomp $(srcdir)/../install-sh \
+	$(srcdir)/../ltmain.sh $(srcdir)/../missing \
+	$(srcdir)/../mkinstalldirs $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in $(srcdir)/config.h.in \
+	$(top_srcdir)/configure ChangeLog
+subdir = .
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \
+	$(top_srcdir)/../config/depstand.m4 \
+	$(top_srcdir)/../config/enable.m4 \
+	$(top_srcdir)/../config/lead-dot.m4 \
+	$(top_srcdir)/../config/tls.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/../libtool.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno configure.status.lineno
+mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
+CONFIG_HEADER = config.h
+CONFIG_CLEAN_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
+am__installdirs = "$(DESTDIR)$(toolexeclibdir)" \
+	"$(DESTDIR)$(libsubincludedir)"
+toolexeclibLTLIBRARIES_INSTALL = $(INSTALL)
+LTLIBRARIES = $(toolexeclib_LTLIBRARIES)
+am_libmudflap_la_OBJECTS = mf-runtime.lo mf-heuristics.lo mf-hooks1.lo \
+	mf-hooks2.lo
+libmudflap_la_OBJECTS = $(am_libmudflap_la_OBJECTS)
+am_libmudflapth_la_OBJECTS =
+libmudflapth_la_OBJECTS = $(am_libmudflapth_la_OBJECTS)
+ at LIBMUDFLAPTH_TRUE@am_libmudflapth_la_rpath = -rpath $(toolexeclibdir)
+DEFAULT_INCLUDES = -I. -I$(srcdir) -I.
+depcomp = $(SHELL) $(top_srcdir)/../depcomp
+am__depfiles_maybe = depfiles
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+SOURCES = $(libmudflap_la_SOURCES) $(libmudflapth_la_SOURCES)
+DIST_SOURCES = $(libmudflap_la_SOURCES) $(libmudflapth_la_SOURCES)
+MULTISRCTOP = 
+MULTIBUILDTOP = 
+MULTIDIRS = 
+MULTISUBDIR = 
+MULTIDO = true
+MULTICLEAN = true
+RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
+	html-recursive info-recursive install-data-recursive \
+	install-exec-recursive install-info-recursive \
+	install-recursive installcheck-recursive installdirs-recursive \
+	pdf-recursive ps-recursive uninstall-info-recursive \
+	uninstall-recursive
+nobase_libsubincludeHEADERS_INSTALL = $(install_sh_DATA)
+HEADERS = $(nobase_libsubinclude_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DIST_SUBDIRS = $(SUBDIRS)
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+  { test ! -d $(distdir) \
+    || { find $(distdir) -type d ! -perm -200 -exec chmod u+w {} ';' \
+         && rm -fr $(distdir); }; }
+DIST_ARCHIVES = $(distdir).tar.gz
+GZIP_ENV = --best
+distuninstallcheck_listfiles = find . -type f -print
+distcleancheck_listfiles = find . -type f -print
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LIBMUDFLAPTH_FALSE = @LIBMUDFLAPTH_FALSE@
+LIBMUDFLAPTH_TRUE = @LIBMUDFLAPTH_TRUE@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MF_HAVE_STDINT_H = @MF_HAVE_STDINT_H@
+MF_HAVE_UINTPTR_T = @MF_HAVE_UINTPTR_T@
+NM = @NM@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SECTION_FLAGS = @SECTION_FLAGS@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_NM = @ac_ct_NM@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_libmudflapth = @build_libmudflapth@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+enable_shared = @enable_shared@
+enable_static = @enable_static@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+multi_basedir = @multi_basedir@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_noncanonical = @target_noncanonical@
+target_os = @target_os@
+target_vendor = @target_vendor@
+toolexecdir = @toolexecdir@
+toolexeclibdir = @toolexeclibdir@
+AUTOMAKE_OPTIONS = 1.8 foreign
+ACLOCAL_AMFLAGS = -I .. -I ../config
+MAINT_CHARSET = latin1
+SUBDIRS = testsuite
+
+# May be used by various substitution variables.
+gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER)
+AM_CFLAGS = -Wall $(SECTION_FLAGS)
+ at LIBMUDFLAPTH_FALSE@libmudflapth = 
+ at LIBMUDFLAPTH_TRUE@libmudflapth = libmudflapth.la
+toolexeclib_LTLIBRARIES = libmudflap.la $(libmudflapth)
+libsubincludedir = $(libdir)/gcc/$(target_noncanonical)/$(gcc_version)/include
+nobase_libsubinclude_HEADERS = mf-runtime.h
+libmudflap_la_SOURCES = \
+	mf-runtime.c \
+	mf-heuristics.c \
+	mf-hooks1.c \
+	mf-hooks2.c
+
+libmudflap_la_LIBADD = 
+libmudflap_la_DEPENDENCIES = $(libmudflap_la_LIBADD)
+libmudflap_la_LDFLAGS = -version-info `grep -v '^\#' $(srcdir)/libtool-version`
+libmudflapth_la_SOURCES = 
+libmudflapth_la_LIBADD = \
+	pth/mf-runtime.lo \
+	pth/mf-heuristics.lo \
+	pth/mf-hooks1.lo \
+	pth/mf-hooks2.lo \
+	pth/mf-hooks3.lo
+
+libmudflapth_la_DEPENDENCIES = $(libmudflapth_la_LIBADD)
+libmudflapth_la_LDFLAGS = -version-info `grep -v '^\#' $(srcdir)/libtool-version`
+
+# XXX hack alert
+# From libffi/Makefile.am
+
+# Work around what appears to be a GNU make bug handling MAKEFLAGS
+# values defined in terms of make variables, as is the case for CC and
+# friends when we are called from the top level Makefile.
+AM_MAKEFLAGS = \
+	"AR_FLAGS=$(AR_FLAGS)" \
+	"CC_FOR_BUILD=$(CC_FOR_BUILD)" \
+	"CFLAGS=$(CFLAGS)" \
+	"CXXFLAGS=$(CXXFLAGS)" \
+	"CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \
+	"CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \
+	"INSTALL=$(INSTALL)" \
+	"INSTALL_DATA=$(INSTALL_DATA)" \
+	"INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
+	"INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \
+	"JC1FLAGS=$(JC1FLAGS)" \
+	"LDFLAGS=$(LDFLAGS)" \
+	"LIBCFLAGS=$(LIBCFLAGS)" \
+	"LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \
+	"MAKE=$(MAKE)" \
+	"MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \
+	"PICFLAG=$(PICFLAG)" \
+	"PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \
+	"SHELL=$(SHELL)" \
+	"RUNTESTFLAGS=$(RUNTESTFLAGS)" \
+	"exec_prefix=$(exec_prefix)" \
+	"infodir=$(infodir)" \
+	"libdir=$(libdir)" \
+	"prefix=$(prefix)" \
+	"includedir=$(includedir)" \
+	"AR=$(AR)" \
+	"AS=$(AS)" \
+	"CC=$(CC)" \
+	"CXX=$(CXX)" \
+	"LD=$(LD)" \
+	"LIBCFLAGS=$(LIBCFLAGS)" \
+	"NM=$(NM)" \
+	"PICFLAG=$(PICFLAG)" \
+	"RANLIB=$(RANLIB)" \
+	"DESTDIR=$(DESTDIR)"
+
+MAKEOVERRIDES = 
+all: config.h
+	$(MAKE) $(AM_MAKEFLAGS) all-recursive
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+am--refresh:
+	@:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign '; \
+	      cd $(srcdir) && $(AUTOMAKE) --foreign  \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign  Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    echo ' $(SHELL) ./config.status'; \
+	    $(SHELL) ./config.status;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	$(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+
+config.h: stamp-h1
+	@if test ! -f $@; then \
+	  rm -f stamp-h1; \
+	  $(MAKE) stamp-h1; \
+	else :; fi
+
+stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
+	@rm -f stamp-h1
+	cd $(top_builddir) && $(SHELL) ./config.status config.h
+$(srcdir)/config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) 
+	cd $(top_srcdir) && $(AUTOHEADER)
+	rm -f stamp-h1
+	touch $@
+
+distclean-hdr:
+	-rm -f config.h stamp-h1
+install-toolexeclibLTLIBRARIES: $(toolexeclib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	test -z "$(toolexeclibdir)" || $(mkdir_p) "$(DESTDIR)$(toolexeclibdir)"
+	@list='$(toolexeclib_LTLIBRARIES)'; for p in $$list; do \
+	  if test -f $$p; then \
+	    f=$(am__strip_dir) \
+	    echo " $(LIBTOOL) --mode=install $(toolexeclibLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(toolexeclibdir)/$$f'"; \
+	    $(LIBTOOL) --mode=install $(toolexeclibLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(toolexeclibdir)/$$f"; \
+	  else :; fi; \
+	done
+
+uninstall-toolexeclibLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@set -x; list='$(toolexeclib_LTLIBRARIES)'; for p in $$list; do \
+	  p=$(am__strip_dir) \
+	  echo " $(LIBTOOL) --mode=uninstall rm -f '$(DESTDIR)$(toolexeclibdir)/$$p'"; \
+	  $(LIBTOOL) --mode=uninstall rm -f "$(DESTDIR)$(toolexeclibdir)/$$p"; \
+	done
+
+clean-toolexeclibLTLIBRARIES:
+	-test -z "$(toolexeclib_LTLIBRARIES)" || rm -f $(toolexeclib_LTLIBRARIES)
+	@list='$(toolexeclib_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+libmudflap.la: $(libmudflap_la_OBJECTS) $(libmudflap_la_DEPENDENCIES) 
+	$(LINK) -rpath $(toolexeclibdir) $(libmudflap_la_LDFLAGS) $(libmudflap_la_OBJECTS) $(libmudflap_la_LIBADD) $(LIBS)
+libmudflapth.la: $(libmudflapth_la_OBJECTS) $(libmudflapth_la_DEPENDENCIES) 
+	$(LINK) $(am_libmudflapth_la_rpath) $(libmudflapth_la_LDFLAGS) $(libmudflapth_la_OBJECTS) $(libmudflapth_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+ at AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/mf-heuristics.Plo at am__quote@
+ at AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/mf-hooks1.Plo at am__quote@
+ at AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/mf-hooks2.Plo at am__quote@
+ at AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/mf-runtime.Plo at am__quote@
+
+.c.o:
+ at am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+ at am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+ at AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+ at AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+ at am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+ at am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ `$(CYGPATH_W) '$<'`; \
+ at am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+ at AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+ at AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+ at am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+ at am__fastdepCC_TRUE@	if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \
+ at am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; fi
+ at AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+ at AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+ at am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+
+# GNU Make needs to see an explicit $(MAKE) variable in the command it
+# runs to enable its job server during parallel builds.  Hence the
+# comments below.
+all-multi:
+	$(MULTIDO) $(AM_MAKEFLAGS) DO=all multi-do # $(MAKE)
+install-multi:
+	$(MULTIDO) $(AM_MAKEFLAGS) DO=install multi-do # $(MAKE)
+
+mostlyclean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=mostlyclean multi-clean # $(MAKE)
+clean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=clean multi-clean # $(MAKE)
+distclean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean # $(MAKE)
+maintainer-clean-multi:
+	$(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean # $(MAKE)
+uninstall-info-am:
+install-nobase_libsubincludeHEADERS: $(nobase_libsubinclude_HEADERS)
+	@$(NORMAL_INSTALL)
+	test -z "$(libsubincludedir)" || $(mkdir_p) "$(DESTDIR)$(libsubincludedir)"
+	@$(am__vpath_adj_setup) \
+	list='$(nobase_libsubinclude_HEADERS)'; for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  $(am__vpath_adj) \
+	  echo " $(nobase_libsubincludeHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(libsubincludedir)/$$f'"; \
+	  $(nobase_libsubincludeHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(libsubincludedir)/$$f"; \
+	done
+
+uninstall-nobase_libsubincludeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@$(am__vpath_adj_setup) \
+	list='$(nobase_libsubinclude_HEADERS)'; for p in $$list; do \
+	  $(am__vpath_adj) \
+	  echo " rm -f '$(DESTDIR)$(libsubincludedir)/$$f'"; \
+	  rm -f "$(DESTDIR)$(libsubincludedir)/$$f"; \
+	done
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run `make' without going through this Makefile.
+# To change the values of `make' variables: instead of editing Makefiles,
+# (1) if the variable is set in `config.status', edit `config.status'
+#     (which will cause the Makefiles to be regenerated when you run `make');
+# (2) otherwise, pass the desired values on the `make' command line.
+$(RECURSIVE_TARGETS):
+	@failcom='exit 1'; \
+	for f in x $$MAKEFLAGS; do \
+	  case $$f in \
+	    *=* | --[!k]*);; \
+	    *k*) failcom='fail=yes';; \
+	  esac; \
+	done; \
+	dot_seen=no; \
+	target=`echo $@ | sed s/-recursive//`; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    dot_seen=yes; \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done; \
+	if test "$$dot_seen" = "no"; then \
+	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+	fi; test -z "$$fail"
+
+mostlyclean-recursive clean-recursive distclean-recursive \
+maintainer-clean-recursive:
+	@failcom='exit 1'; \
+	for f in x $$MAKEFLAGS; do \
+	  case $$f in \
+	    *=* | --[!k]*);; \
+	    *k*) failcom='fail=yes';; \
+	  esac; \
+	done; \
+	dot_seen=no; \
+	case "$@" in \
+	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+	  *) list='$(SUBDIRS)' ;; \
+	esac; \
+	rev=''; for subdir in $$list; do \
+	  if test "$$subdir" = "."; then :; else \
+	    rev="$$subdir $$rev"; \
+	  fi; \
+	done; \
+	rev="$$rev ."; \
+	target=`echo $@ | sed s/-recursive//`; \
+	for subdir in $$rev; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done && test -z "$$fail"
+tags-recursive:
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
+	done
+ctags-recursive:
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
+	done
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS: tags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+	  include_option=--etags-include; \
+	  empty_fix=.; \
+	else \
+	  include_option=--include; \
+	  empty_fix=; \
+	fi; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test ! -f $$subdir/TAGS || \
+	      tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \
+	  fi; \
+	done; \
+	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	    $$tags $$unique; \
+	fi
+ctags: CTAGS
+CTAGS: ctags-recursive $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	$(am__remove_distdir)
+	mkdir $(distdir)
+	$(mkdir_p) $(distdir)/.. $(distdir)/../config $(distdir)/testsuite
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkdir_p) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+	list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test -d "$(distdir)/$$subdir" \
+	    || $(mkdir_p) "$(distdir)/$$subdir" \
+	    || exit 1; \
+	    distdir=`$(am__cd) $(distdir) && pwd`; \
+	    top_distdir=`$(am__cd) $(top_distdir) && pwd`; \
+	    (cd $$subdir && \
+	      $(MAKE) $(AM_MAKEFLAGS) \
+	        top_distdir="$$top_distdir" \
+	        distdir="$$distdir/$$subdir" \
+	        distdir) \
+	      || exit 1; \
+	  fi; \
+	done
+	-find $(distdir) -type d ! -perm -777 -exec chmod a+rwx {} \; -o \
+	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -444 -exec $(SHELL) $(install_sh) -c -m a+r {} {} \; \
+	|| chmod -R a+r $(distdir)
+dist-gzip: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	$(am__remove_distdir)
+
+dist-bzip2: distdir
+	tardir=$(distdir) && $(am__tar) | bzip2 -9 -c >$(distdir).tar.bz2
+	$(am__remove_distdir)
+
+dist-tarZ: distdir
+	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+	$(am__remove_distdir)
+
+dist-shar: distdir
+	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
+	$(am__remove_distdir)
+
+dist-zip: distdir
+	-rm -f $(distdir).zip
+	zip -rq $(distdir).zip $(distdir)
+	$(am__remove_distdir)
+
+dist dist-all: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	$(am__remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration.  Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+	case '$(DIST_ARCHIVES)' in \
+	*.tar.gz*) \
+	  GZIP=$(GZIP_ENV) gunzip -c $(distdir).tar.gz | $(am__untar) ;;\
+	*.tar.bz2*) \
+	  bunzip2 -c $(distdir).tar.bz2 | $(am__untar) ;;\
+	*.tar.Z*) \
+	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+	*.shar.gz*) \
+	  GZIP=$(GZIP_ENV) gunzip -c $(distdir).shar.gz | unshar ;;\
+	*.zip*) \
+	  unzip $(distdir).zip ;;\
+	esac
+	chmod -R a-w $(distdir); chmod a+w $(distdir)
+	mkdir $(distdir)/_build
+	mkdir $(distdir)/_inst
+	chmod a-w $(distdir)
+	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+	  && cd $(distdir)/_build \
+	  && ../configure --srcdir=.. --prefix="$$dc_install_base" \
+	    $(DISTCHECK_CONFIGURE_FLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
+	  && $(MAKE) $(AM_MAKEFLAGS) check \
+	  && $(MAKE) $(AM_MAKEFLAGS) install \
+	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+	        distuninstallcheck \
+	  && chmod -R a-w "$$dc_install_base" \
+	  && ({ \
+	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
+	  && rm -rf "$$dc_destdir" \
+	  && $(MAKE) $(AM_MAKEFLAGS) dist \
+	  && rm -rf $(DIST_ARCHIVES) \
+	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck
+	$(am__remove_distdir)
+	@(echo "$(distdir) archives ready for distribution: "; \
+	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+	  sed -e '1{h;s/./=/g;p;x;}' -e '$${p;x;}'
+distuninstallcheck:
+	@cd $(distuninstallcheck_dir) \
+	&& test `$(distuninstallcheck_listfiles) | wc -l` -le 1 \
+	   || { echo "ERROR: files left after uninstall:" ; \
+	        if test -n "$(DESTDIR)"; then \
+	          echo "  (check DESTDIR support)"; \
+	        fi ; \
+	        $(distuninstallcheck_listfiles) ; \
+	        exit 1; } >&2
+distcleancheck: distclean
+	@if test '$(srcdir)' = . ; then \
+	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+	  exit 1 ; \
+	fi
+	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+	  || { echo "ERROR: files left in build directory after distclean:" ; \
+	       $(distcleancheck_listfiles) ; \
+	       exit 1; } >&2
+check-am: all-am
+check: check-recursive
+all-am: Makefile $(LTLIBRARIES) all-multi $(HEADERS) config.h
+installdirs: installdirs-recursive
+installdirs-am:
+	for dir in "$(DESTDIR)$(toolexeclibdir)" "$(DESTDIR)$(libsubincludedir)"; do \
+	  test -z "$$dir" || $(mkdir_p) "$$dir"; \
+	done
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-multi clean-recursive
+
+clean-am: clean-generic clean-libtool clean-local \
+	clean-toolexeclibLTLIBRARIES mostlyclean-am
+
+distclean: distclean-multi distclean-recursive
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-hdr distclean-libtool distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+info: info-recursive
+
+info-am:
+
+install-data-am: install-nobase_libsubincludeHEADERS
+
+install-exec-am: install-multi install-toolexeclibLTLIBRARIES
+
+install-info: install-info-recursive
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-multi maintainer-clean-recursive
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf $(top_srcdir)/autom4te.cache
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-multi mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am: uninstall-info-am uninstall-nobase_libsubincludeHEADERS \
+	uninstall-toolexeclibLTLIBRARIES
+
+uninstall-info: uninstall-info-recursive
+
+.PHONY: $(RECURSIVE_TARGETS) CTAGS GTAGS all all-am all-multi \
+	am--refresh check check-am clean clean-generic clean-libtool \
+	clean-local clean-multi clean-recursive \
+	clean-toolexeclibLTLIBRARIES ctags ctags-recursive dist \
+	dist-all dist-bzip2 dist-gzip dist-shar dist-tarZ dist-zip \
+	distcheck distclean distclean-compile distclean-generic \
+	distclean-hdr distclean-libtool distclean-multi \
+	distclean-recursive distclean-tags distcleancheck distdir \
+	distuninstallcheck dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-exec \
+	install-exec-am install-info install-info-am install-man \
+	install-multi install-nobase_libsubincludeHEADERS \
+	install-strip install-toolexeclibLTLIBRARIES installcheck \
+	installcheck-am installdirs installdirs-am maintainer-clean \
+	maintainer-clean-generic maintainer-clean-multi \
+	maintainer-clean-recursive mostlyclean mostlyclean-compile \
+	mostlyclean-generic mostlyclean-libtool mostlyclean-multi \
+	mostlyclean-recursive pdf pdf-am ps ps-am tags tags-recursive \
+	uninstall uninstall-am uninstall-info-am \
+	uninstall-nobase_libsubincludeHEADERS \
+	uninstall-toolexeclibLTLIBRARIES
+
+
+clean-local:
+	rm -f pth/*.o pth/*.lo
+
+pth/mf-runtime.lo: mf-runtime.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-runtime.c -o $@
+pth/mf-heuristics.lo: mf-heuristics.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-heuristics.c -o $@
+pth/mf-hooks1.lo: mf-hooks1.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-hooks1.c -o $@
+pth/mf-hooks2.lo: mf-hooks2.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-hooks2.c -o $@
+pth/mf-hooks3.lo: mf-hooks3.c mf-runtime.h mf-impl.h
+	$(LTCOMPILE) -DLIBMUDFLAPTH -c $(srcdir)/mf-hooks3.c -o $@
+
+.PHONY: install-html
+
+install-html:
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

Added: llvm-gcc-4.2/trunk/libmudflap/acinclude.m4
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/acinclude.m4?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/acinclude.m4 (added)
+++ llvm-gcc-4.2/trunk/libmudflap/acinclude.m4 Thu Nov  8 16:56:19 2007
@@ -0,0 +1,12 @@
+dnl ----------------------------------------------------------------------
+dnl This whole bit snagged from libgfortran.
+
+sinclude(../libtool.m4)
+dnl The lines below arrange for aclocal not to bring an installed
+dnl libtool.m4 into aclocal.m4, while still arranging for automake to
+dnl add a definition of LIBTOOL to Makefile.in.
+ifelse(,,,[AC_SUBST(LIBTOOL)
+AC_DEFUN([AM_PROG_LIBTOOL])
+AC_DEFUN([AC_LIBTOOL_DLOPEN])
+AC_DEFUN([AC_PROG_LD])
+])

Added: llvm-gcc-4.2/trunk/libmudflap/aclocal.m4
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/aclocal.m4?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/aclocal.m4 (added)
+++ llvm-gcc-4.2/trunk/libmudflap/aclocal.m4 Thu Nov  8 16:56:19 2007
@@ -0,0 +1,922 @@
+# generated automatically by aclocal 1.9.6 -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005  Free Software Foundation, Inc.
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+# Copyright (C) 2002, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_AUTOMAKE_VERSION(VERSION)
+# ----------------------------
+# Automake X.Y traces this macro to ensure aclocal.m4 has been
+# generated from the m4 files accompanying Automake X.Y.
+AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version="1.9"])
+
+# AM_SET_CURRENT_AUTOMAKE_VERSION
+# -------------------------------
+# Call AM_AUTOMAKE_VERSION so it can be traced.
+# This function is AC_REQUIREd by AC_INIT_AUTOMAKE.
+AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+	 [AM_AUTOMAKE_VERSION([1.9.6])])
+
+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+
+# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
+# $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
+# `$srcdir', `$srcdir/..', or `$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory.  The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run.  This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+#    fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+#    fails if $ac_aux_dir is absolute,
+#    fails when called from a subdirectory in a VPATH build with
+#          a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir.  In an in-source build this is usually
+# harmless because $srcdir is `.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
+# and then we would define $MISSING as
+#   MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH.  The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN([AM_AUX_DIR_EXPAND],
+[dnl Rely on autoconf to set up CDPATH properly.
+AC_PREREQ([2.50])dnl
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+])
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 7
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN([AM_CONDITIONAL],
+[AC_PREREQ(2.52)dnl
+ ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
+	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+AC_SUBST([$1_TRUE])
+AC_SUBST([$1_FALSE])
+if $2; then
+  $1_TRUE=
+  $1_FALSE='#'
+else
+  $1_TRUE='#'
+  $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+  AC_MSG_ERROR([[conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.]])
+fi])])
+
+
+# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 8
+
+# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
+# written in clear, in which case automake, when reading aclocal.m4,
+# will think it sees a *use*, and therefore will trigger all it's
+# C support machinery.  Also note that it means that autoscan, seeing
+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
+
+
+# _AM_DEPENDENCIES(NAME)
+# ----------------------
+# See how the compiler implements dependency checking.
+# NAME is "CC", "CXX", "GCJ", or "OBJC".
+# We try a few techniques and use that to set a single cache variable.
+#
+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
+# dependency, and given that the user is not expected to run this macro,
+# just rely on AC_PROG_CC.
+AC_DEFUN([_AM_DEPENDENCIES],
+[AC_REQUIRE([AM_SET_DEPDIR])dnl
+AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
+AC_REQUIRE([AM_MAKE_INCLUDE])dnl
+AC_REQUIRE([AM_DEP_TRACK])dnl
+
+ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],
+       [$1], CXX,  [depcc="$CXX"  am_compiler_list=],
+       [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+       [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
+                   [depcc="$$1"   am_compiler_list=])
+
+AC_CACHE_CHECK([dependency style of $depcc],
+               [am_cv_$1_dependencies_compiler_type],
+[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named `D' -- because `-MD' means `put the output
+  # in D'.
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_$1_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
+  fi
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
+      # Solaris 8's {/usr,}/bin/sh.
+      touch sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    case $depmode in
+    nosideeffect)
+      # after this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    none) break ;;
+    esac
+    # We check with `-c' and `-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle `-M -o', and we need to detect this.
+    if depmode=$depmode \
+       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_$1_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_$1_dependencies_compiler_type=none
+fi
+])
+AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
+AM_CONDITIONAL([am__fastdep$1], [
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
+])
+
+
+# AM_SET_DEPDIR
+# -------------
+# Choose a directory name for dependency files.
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES
+AC_DEFUN([AM_SET_DEPDIR],
+[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
+])
+
+
+# AM_DEP_TRACK
+# ------------
+AC_DEFUN([AM_DEP_TRACK],
+[AC_ARG_ENABLE(dependency-tracking,
+[  --disable-dependency-tracking  speeds up one-time build
+  --enable-dependency-tracking   do not reject slow dependency extractors])
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+fi
+AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
+AC_SUBST([AMDEPBACKSLASH])
+])
+
+# Generate code to set up dependency tracking.              -*- Autoconf -*-
+
+# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+#serial 3
+
+# _AM_OUTPUT_DEPENDENCY_COMMANDS
+# ------------------------------
+AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
+[for mf in $CONFIG_FILES; do
+  # Strip MF so we end up with the name of the file.
+  mf=`echo "$mf" | sed -e 's/:.*$//'`
+  # Check whether this is an Automake generated Makefile or not.
+  # We used to match only the files named `Makefile.in', but
+  # some people rename them; so instead we look at the file content.
+  # Grep'ing the first line is not enough: some people post-process
+  # each Makefile.in and add a new line on top of each file to say so.
+  # So let's grep whole file.
+  if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+    dirpart=`AS_DIRNAME("$mf")`
+  else
+    continue
+  fi
+  # Extract the definition of DEPDIR, am__include, and am__quote
+  # from the Makefile without running `make'.
+  DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+  test -z "$DEPDIR" && continue
+  am__include=`sed -n 's/^am__include = //p' < "$mf"`
+  test -z "am__include" && continue
+  am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+  # When using ansi2knr, U may be empty or an underscore; expand it
+  U=`sed -n 's/^U = //p' < "$mf"`
+  # Find all dependency output files, they are included files with
+  # $(DEPDIR) in their names.  We invoke sed twice because it is the
+  # simplest approach to changing $(DEPDIR) to its actual value in the
+  # expansion.
+  for file in `sed -n "
+    s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+       sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+    # Make sure the directory exists.
+    test -f "$dirpart/$file" && continue
+    fdir=`AS_DIRNAME(["$file"])`
+    AS_MKDIR_P([$dirpart/$fdir])
+    # echo "creating $dirpart/$file"
+    echo '# dummy' > "$dirpart/$file"
+  done
+done
+])# _AM_OUTPUT_DEPENDENCY_COMMANDS
+
+
+# AM_OUTPUT_DEPENDENCY_COMMANDS
+# -----------------------------
+# This macro should only be invoked once -- use via AC_REQUIRE.
+#
+# This code is only required when automatic dependency tracking
+# is enabled.  FIXME.  This creates each `.P' file that we will
+# need in order to bootstrap the dependency handling code.
+AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
+[AC_CONFIG_COMMANDS([depfiles],
+     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
+     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
+])
+
+# Do all the work for Automake.                             -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 12
+
+# This macro actually does too much.  Some checks are only needed if
+# your package does certain things.  But this isn't really a big deal.
+
+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
+# AM_INIT_AUTOMAKE([OPTIONS])
+# -----------------------------------------------
+# The call with PACKAGE and VERSION arguments is the old style
+# call (pre autoconf-2.50), which is being phased out.  PACKAGE
+# and VERSION should now be passed to AC_INIT and removed from
+# the call to AM_INIT_AUTOMAKE.
+# We support both call styles for the transition.  After
+# the next Automake release, Autoconf can make the AC_INIT
+# arguments mandatory, and then we can depend on a new Autoconf
+# release and drop the old call support.
+AC_DEFUN([AM_INIT_AUTOMAKE],
+[AC_PREREQ([2.58])dnl
+dnl Autoconf wants to disallow AM_ names.  We explicitly allow
+dnl the ones we care about.
+m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
+AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
+AC_REQUIRE([AC_PROG_INSTALL])dnl
+# test to see if srcdir already configured
+if test "`cd $srcdir && pwd`" != "`pwd`" &&
+   test -f $srcdir/config.status; then
+  AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+AC_SUBST([CYGPATH_W])
+
+# Define the identity of the package.
+dnl Distinguish between old-style and new-style calls.
+m4_ifval([$2],
+[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
+ AC_SUBST([PACKAGE], [$1])dnl
+ AC_SUBST([VERSION], [$2])],
+[_AM_SET_OPTIONS([$1])dnl
+ AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
+ AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
+
+_AM_IF_OPTION([no-define],,
+[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
+ AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl
+
+# Some tools Automake needs.
+AC_REQUIRE([AM_SANITY_CHECK])dnl
+AC_REQUIRE([AC_ARG_PROGRAM])dnl
+AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
+AM_MISSING_PROG(AUTOCONF, autoconf)
+AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
+AM_MISSING_PROG(AUTOHEADER, autoheader)
+AM_MISSING_PROG(MAKEINFO, makeinfo)
+AM_PROG_INSTALL_SH
+AM_PROG_INSTALL_STRIP
+AC_REQUIRE([AM_PROG_MKDIR_P])dnl
+# We need awk for the "check" target.  The system "awk" is bad on
+# some platforms.
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([AC_PROG_MAKE_SET])dnl
+AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
+              [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
+	      		     [_AM_PROG_TAR([v7])])])
+_AM_IF_OPTION([no-dependencies],,
+[AC_PROVIDE_IFELSE([AC_PROG_CC],
+                  [_AM_DEPENDENCIES(CC)],
+                  [define([AC_PROG_CC],
+                          defn([AC_PROG_CC])[_AM_DEPENDENCIES(CC)])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_CXX],
+                  [_AM_DEPENDENCIES(CXX)],
+                  [define([AC_PROG_CXX],
+                          defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
+])
+])
+
+
+# When config.status generates a header, we must update the stamp-h file.
+# This file resides in the same directory as the config header
+# that is generated.  The stamp files are numbered to have different names.
+
+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
+# loop where config.status creates the headers, so we can generate
+# our stamp files there.
+AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
+[# Compute $1's index in $config_headers.
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $1 | $1:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $1" >`AS_DIRNAME([$1])`/stamp-h[]$_am_stamp_count])
+
+# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_SH
+# ------------------
+# Define $install_sh.
+AC_DEFUN([AM_PROG_INSTALL_SH],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+install_sh=${install_sh-"$am_aux_dir/install-sh"}
+AC_SUBST(install_sh)])
+
+# Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
+# From Jim Meyering
+
+# Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 4
+
+AC_DEFUN([AM_MAINTAINER_MODE],
+[AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
+  dnl maintainer-mode is disabled by default
+  AC_ARG_ENABLE(maintainer-mode,
+[  --enable-maintainer-mode  enable make rules and dependencies not useful
+			  (and sometimes confusing) to the casual installer],
+      USE_MAINTAINER_MODE=$enableval,
+      USE_MAINTAINER_MODE=no)
+  AC_MSG_RESULT([$USE_MAINTAINER_MODE])
+  AM_CONDITIONAL(MAINTAINER_MODE, [test $USE_MAINTAINER_MODE = yes])
+  MAINT=$MAINTAINER_MODE_TRUE
+  AC_SUBST(MAINT)dnl
+]
+)
+
+AU_DEFUN([jm_MAINTAINER_MODE], [AM_MAINTAINER_MODE])
+
+# Check to see how 'make' treats includes.	            -*- Autoconf -*-
+
+# Copyright (C) 2001, 2002, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 3
+
+# AM_MAKE_INCLUDE()
+# -----------------
+# Check to see how make treats includes.
+AC_DEFUN([AM_MAKE_INCLUDE],
+[am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+	@echo done
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+AC_MSG_CHECKING([for style of include used by $am_make])
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# We grep out `Entering directory' and `Leaving directory'
+# messages which can occur if `w' ends up in MAKEFLAGS.
+# In particular we don't look at `^make:' because GNU make might
+# be invoked under some other name (usually "gmake"), in which
+# case it prints its new name instead of `make'.
+if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
+   am__include=include
+   am__quote=
+   _am_result=GNU
+fi
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+   echo '.include "confinc"' > confmf
+   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
+      am__include=.include
+      am__quote="\""
+      _am_result=BSD
+   fi
+fi
+AC_SUBST([am__include])
+AC_SUBST([am__quote])
+AC_MSG_RESULT([$_am_result])
+rm -f confinc confmf
+])
+
+# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
+
+# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 4
+
+# AM_MISSING_PROG(NAME, PROGRAM)
+# ------------------------------
+AC_DEFUN([AM_MISSING_PROG],
+[AC_REQUIRE([AM_MISSING_HAS_RUN])
+$1=${$1-"${am_missing_run}$2"}
+AC_SUBST($1)])
+
+
+# AM_MISSING_HAS_RUN
+# ------------------
+# Define MISSING if not defined so far and test if it supports --run.
+# If it does, set am_missing_run to use it, otherwise, to nothing.
+AC_DEFUN([AM_MISSING_HAS_RUN],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
+# Use eval to expand $SHELL
+if eval "$MISSING --run true"; then
+  am_missing_run="$MISSING --run "
+else
+  am_missing_run=
+  AC_MSG_WARN([`missing' script is too old or missing])
+fi
+])
+
+# Copyright (C) 2003, 2004, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_MKDIR_P
+# ---------------
+# Check whether `mkdir -p' is supported, fallback to mkinstalldirs otherwise.
+#
+# Automake 1.8 used `mkdir -m 0755 -p --' to ensure that directories
+# created by `make install' are always world readable, even if the
+# installer happens to have an overly restrictive umask (e.g. 077).
+# This was a mistake.  There are at least two reasons why we must not
+# use `-m 0755':
+#   - it causes special bits like SGID to be ignored,
+#   - it may be too restrictive (some setups expect 775 directories).
+#
+# Do not use -m 0755 and let people choose whatever they expect by
+# setting umask.
+#
+# We cannot accept any implementation of `mkdir' that recognizes `-p'.
+# Some implementations (such as Solaris 8's) are not thread-safe: if a
+# parallel make tries to run `mkdir -p a/b' and `mkdir -p a/c'
+# concurrently, both version can detect that a/ is missing, but only
+# one can create it and the other will error out.  Consequently we
+# restrict ourselves to GNU make (using the --version option ensures
+# this.)
+AC_DEFUN([AM_PROG_MKDIR_P],
+[if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
+  # We used to keeping the `.' as first argument, in order to
+  # allow $(mkdir_p) to be used without argument.  As in
+  #   $(mkdir_p) $(somedir)
+  # where $(somedir) is conditionally defined.  However this is wrong
+  # for two reasons:
+  #  1. if the package is installed by a user who cannot write `.'
+  #     make install will fail,
+  #  2. the above comment should most certainly read
+  #     $(mkdir_p) $(DESTDIR)$(somedir)
+  #     so it does not work when $(somedir) is undefined and
+  #     $(DESTDIR) is not.
+  #  To support the latter case, we have to write
+  #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
+  #  so the `.' trick is pointless.
+  mkdir_p='mkdir -p --'
+else
+  # On NextStep and OpenStep, the `mkdir' command does not
+  # recognize any option.  It will interpret all options as
+  # directories to create, and then abort because `.' already
+  # exists.
+  for d in ./-p ./--version;
+  do
+    test -d $d && rmdir $d
+  done
+  # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
+  if test -f "$ac_aux_dir/mkinstalldirs"; then
+    mkdir_p='$(mkinstalldirs)'
+  else
+    mkdir_p='$(install_sh) -d'
+  fi
+fi
+AC_SUBST([mkdir_p])])
+
+# Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 5
+
+# AM_ENABLE_MULTILIB([MAKEFILE], [REL-TO-TOP-SRCDIR])
+# ---------------------------------------------------
+# Add --enable-multilib to configure.
+AC_DEFUN([AM_ENABLE_MULTILIB],
+[# Default to --enable-multilib
+AC_ARG_ENABLE(multilib,
+[  --enable-multilib       build many library versions (default)],
+[case "$enableval" in
+  yes) multilib=yes ;;
+  no)  multilib=no ;;
+  *)   AC_MSG_ERROR([bad value $enableval for multilib option]) ;;
+ esac],
+	      [multilib=yes])
+
+# We may get other options which we leave undocumented:
+# --with-target-subdir, --with-multisrctop, --with-multisubdir
+# See config-ml.in if you want the gory details.
+
+if test "$srcdir" = "."; then
+  if test "$with_target_subdir" != "."; then
+    multi_basedir="$srcdir/$with_multisrctop../$2"
+  else
+    multi_basedir="$srcdir/$with_multisrctop$2"
+  fi
+else
+  multi_basedir="$srcdir/$2"
+fi
+AC_SUBST(multi_basedir)
+
+AC_OUTPUT_COMMANDS([
+# Only add multilib support code if we just rebuilt the top-level
+# Makefile.
+case " $CONFIG_FILES " in
+ *" ]m4_default([$1],Makefile)[ "*)
+   ac_file=]m4_default([$1],Makefile)[ . ${multi_basedir}/config-ml.in
+   ;;
+esac],
+		   [
+srcdir="$srcdir"
+host="$host"
+target="$target"
+with_multisubdir="$with_multisubdir"
+with_multisrctop="$with_multisrctop"
+with_target_subdir="$with_target_subdir"
+ac_configure_args="${multilib_arg} ${ac_configure_args}"
+multi_basedir="$multi_basedir"
+CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+CC="$CC"])])dnl
+
+# Helper functions for option handling.                     -*- Autoconf -*-
+
+# Copyright (C) 2001, 2002, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 3
+
+# _AM_MANGLE_OPTION(NAME)
+# -----------------------
+AC_DEFUN([_AM_MANGLE_OPTION],
+[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
+
+# _AM_SET_OPTION(NAME)
+# ------------------------------
+# Set option NAME.  Presently that only means defining a flag for this option.
+AC_DEFUN([_AM_SET_OPTION],
+[m4_define(_AM_MANGLE_OPTION([$1]), 1)])
+
+# _AM_SET_OPTIONS(OPTIONS)
+# ----------------------------------
+# OPTIONS is a space-separated list of Automake options.
+AC_DEFUN([_AM_SET_OPTIONS],
+[AC_FOREACH([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
+
+# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+AC_DEFUN([_AM_IF_OPTION],
+[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
+
+# Check to make sure that the build environment is sane.    -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 2000, 2001, 2003, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 4
+
+# AM_SANITY_CHECK
+# ---------------
+AC_DEFUN([AM_SANITY_CHECK],
+[AC_MSG_CHECKING([whether build environment is sane])
+# Just in case
+sleep 1
+echo timestamp > conftest.file
+# Do `set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
+   if test "$[*]" = "X"; then
+      # -L didn't work.
+      set X `ls -t $srcdir/configure conftest.file`
+   fi
+   rm -f conftest.file
+   if test "$[*]" != "X $srcdir/configure conftest.file" \
+      && test "$[*]" != "X conftest.file $srcdir/configure"; then
+
+      # If neither matched, then we have a broken ls.  This can happen
+      # if, for instance, CONFIG_SHELL is bash and it inherits a
+      # broken ls alias from the environment.  This has actually
+      # happened.  Such a system could not be considered "sane".
+      AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
+alias in your environment])
+   fi
+
+   test "$[2]" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   AC_MSG_ERROR([newly created file is older than distributed files!
+Check your system clock])
+fi
+AC_MSG_RESULT(yes)])
+
+# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_STRIP
+# ---------------------
+# One issue with vendor `install' (even GNU) is that you can't
+# specify the program used to strip binaries.  This is especially
+# annoying in cross-compiling environments, where the build's strip
+# is unlikely to handle the host's binaries.
+# Fortunately install-sh will honor a STRIPPROG variable, so we
+# always use install-sh in `make install-strip', and initialize
+# STRIPPROG with the value of the STRIP variable (set by the user).
+AC_DEFUN([AM_PROG_INSTALL_STRIP],
+[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+# Installed binaries are usually stripped using `strip' when the user
+# run `make install-strip'.  However `strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the `STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
+if test "$cross_compiling" != no; then
+  AC_CHECK_TOOL([STRIP], [strip], :)
+fi
+INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
+AC_SUBST([INSTALL_STRIP_PROGRAM])])
+
+# Check how to create a tarball.                            -*- Autoconf -*-
+
+# Copyright (C) 2004, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 2
+
+# _AM_PROG_TAR(FORMAT)
+# --------------------
+# Check how to create a tarball in format FORMAT.
+# FORMAT should be one of `v7', `ustar', or `pax'.
+#
+# Substitute a variable $(am__tar) that is a command
+# writing to stdout a FORMAT-tarball containing the directory
+# $tardir.
+#     tardir=directory && $(am__tar) > result.tar
+#
+# Substitute a variable $(am__untar) that extract such
+# a tarball read from stdin.
+#     $(am__untar) < result.tar
+AC_DEFUN([_AM_PROG_TAR],
+[# Always define AMTAR for backward compatibility.
+AM_MISSING_PROG([AMTAR], [tar])
+m4_if([$1], [v7],
+     [am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'],
+     [m4_case([$1], [ustar],, [pax],,
+              [m4_fatal([Unknown tar format])])
+AC_MSG_CHECKING([how to create a $1 tar archive])
+# Loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
+_am_tools=${am_cv_prog_tar_$1-$_am_tools}
+# Do not fold the above two line into one, because Tru64 sh and
+# Solaris sh will not grok spaces in the rhs of `-'.
+for _am_tool in $_am_tools
+do
+  case $_am_tool in
+  gnutar)
+    for _am_tar in tar gnutar gtar;
+    do
+      AM_RUN_LOG([$_am_tar --version]) && break
+    done
+    am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
+    am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
+    am__untar="$_am_tar -xf -"
+    ;;
+  plaintar)
+    # Must skip GNU tar: if it does not support --format= it doesn't create
+    # ustar tarball either.
+    (tar --version) >/dev/null 2>&1 && continue
+    am__tar='tar chf - "$$tardir"'
+    am__tar_='tar chf - "$tardir"'
+    am__untar='tar xf -'
+    ;;
+  pax)
+    am__tar='pax -L -x $1 -w "$$tardir"'
+    am__tar_='pax -L -x $1 -w "$tardir"'
+    am__untar='pax -r'
+    ;;
+  cpio)
+    am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+    am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+    am__untar='cpio -i -H $1 -d'
+    ;;
+  none)
+    am__tar=false
+    am__tar_=false
+    am__untar=false
+    ;;
+  esac
+
+  # If the value was cached, stop now.  We just wanted to have am__tar
+  # and am__untar set.
+  test -n "${am_cv_prog_tar_$1}" && break
+
+  # tar/untar a dummy directory, and stop if the command works
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  echo GrepMe > conftest.dir/file
+  AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+  rm -rf conftest.dir
+  if test -s conftest.tar; then
+    AM_RUN_LOG([$am__untar <conftest.tar])
+    grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+  fi
+done
+rm -rf conftest.dir
+
+AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
+AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+AC_SUBST([am__tar])
+AC_SUBST([am__untar])
+]) # _AM_PROG_TAR
+
+m4_include([../config/acx.m4])
+m4_include([../config/depstand.m4])
+m4_include([../config/enable.m4])
+m4_include([../config/lead-dot.m4])
+m4_include([../config/tls.m4])
+m4_include([acinclude.m4])

Added: llvm-gcc-4.2/trunk/libmudflap/config.h.in
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/config.h.in?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/config.h.in (added)
+++ llvm-gcc-4.2/trunk/libmudflap/config.h.in Thu Nov  8 16:56:19 2007
@@ -0,0 +1,271 @@
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to the name of the symbol used for the entry point. */
+#undef ENTRY_POINT
+
+/* Define to 1 if you have the `addmntent' function. */
+#undef HAVE_ADDMNTENT
+
+/* Define to 1 if you have the <arpa/inet.h> header file. */
+#undef HAVE_ARPA_INET_H
+
+/* Define to 1 if you have the `backtrace' function. */
+#undef HAVE_BACKTRACE
+
+/* Define to 1 if you have the `backtrace_symbols' function. */
+#undef HAVE_BACKTRACE_SYMBOLS
+
+/* Define to 1 if you have the <ctype.h> header file. */
+#undef HAVE_CTYPE_H
+
+/* Define to 1 if you have the `cuserid' function. */
+#undef HAVE_CUSERID
+
+/* Define to 1 if you have the <dirent.h> header file. */
+#undef HAVE_DIRENT_H
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the `dlvsym' function. */
+#undef HAVE_DLVSYM
+
+/* Define to 1 if you have the <execinfo.h> header file. */
+#undef HAVE_EXECINFO_H
+
+/* Define to 1 if you have the `fopen64' function. */
+#undef HAVE_FOPEN64
+
+/* Define to 1 if you have the `freopen64' function. */
+#undef HAVE_FREOPEN64
+
+/* Define to 1 if you have the `fseeko64' function. */
+#undef HAVE_FSEEKO64
+
+/* Define to 1 if you have the `ftello64' function. */
+#undef HAVE_FTELLO64
+
+/* Define to 1 if you have the `gai_strerror' function. */
+#undef HAVE_GAI_STRERROR
+
+/* Define to 1 if you have the `getaddrinfo' function. */
+#undef HAVE_GETADDRINFO
+
+/* Define to 1 if you have the `getgrent' function. */
+#undef HAVE_GETGRENT
+
+/* Define to 1 if you have the `getgrgid' function. */
+#undef HAVE_GETGRGID
+
+/* Define to 1 if you have the `getgrgid_r' function. */
+#undef HAVE_GETGRGID_R
+
+/* Define to 1 if you have the `getgrnam' function. */
+#undef HAVE_GETGRNAM
+
+/* Define to 1 if you have the `getgrnam_r' function. */
+#undef HAVE_GETGRNAM_R
+
+/* Define to 1 if you have the `getlogin' function. */
+#undef HAVE_GETLOGIN
+
+/* Define to 1 if you have the `getlogin_r' function. */
+#undef HAVE_GETLOGIN_R
+
+/* Define to 1 if you have the `getmntent' function. */
+#undef HAVE_GETMNTENT
+
+/* Define to 1 if you have the `getprotobyname' function. */
+#undef HAVE_GETPROTOBYNAME
+
+/* Define to 1 if you have the `getprotobynumber' function. */
+#undef HAVE_GETPROTOBYNUMBER
+
+/* Define to 1 if you have the `getprotoent' function. */
+#undef HAVE_GETPROTOENT
+
+/* Define to 1 if you have the `getpwent' function. */
+#undef HAVE_GETPWENT
+
+/* Define to 1 if you have the `getpwnam' function. */
+#undef HAVE_GETPWNAM
+
+/* Define to 1 if you have the `getpwnam_r' function. */
+#undef HAVE_GETPWNAM_R
+
+/* Define to 1 if you have the `getpwuid' function. */
+#undef HAVE_GETPWUID
+
+/* Define to 1 if you have the `getpwuid_r' function. */
+#undef HAVE_GETPWUID_R
+
+/* Define to 1 if you have the `getservbyname' function. */
+#undef HAVE_GETSERVBYNAME
+
+/* Define to 1 if you have the `getservbyport' function. */
+#undef HAVE_GETSERVBYPORT
+
+/* Define to 1 if you have the `getservent' function. */
+#undef HAVE_GETSERVENT
+
+/* Define to 1 if you have the `gettimeofday' function. */
+#undef HAVE_GETTIMEOFDAY
+
+/* Define to 1 if you have the <grp.h> header file. */
+#undef HAVE_GRP_H
+
+/* Define to 1 if you have the `inet_ntoa' function. */
+#undef HAVE_INET_NTOA
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the `dl' library (-ldl). */
+#undef HAVE_LIBDL
+
+/* Define to 1 if you have the `memmem' function. */
+#undef HAVE_MEMMEM
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the `memrchr' function. */
+#undef HAVE_MEMRCHR
+
+/* Define to 1 if you have the `mmap' function. */
+#undef HAVE_MMAP
+
+/* Define to 1 if you have the <mntent.h> header file. */
+#undef HAVE_MNTENT_H
+
+/* Define to 1 if you have the `munmap' function. */
+#undef HAVE_MUNMAP
+
+/* Define to 1 if you have the <netdb.h> header file. */
+#undef HAVE_NETDB_H
+
+/* Define to 1 if you have the <netinet/in.h> header file. */
+#undef HAVE_NETINET_IN_H
+
+/* Define to 1 if you have the <pthread.h> header file. */
+#undef HAVE_PTHREAD_H
+
+/* Define to 1 if you have the <pwd.h> header file. */
+#undef HAVE_PWD_H
+
+/* Define to 1 if you have the `setbuf' function. */
+#undef HAVE_SETBUF
+
+/* Define to 1 if you have the `setbuffer' function. */
+#undef HAVE_SETBUFFER
+
+/* Define to 1 if you have the `sethostname' function. */
+#undef HAVE_SETHOSTNAME
+
+/* Define to 1 if you have the `setlinebuf' function. */
+#undef HAVE_SETLINEBUF
+
+/* Define to 1 if you have the `setmntent' function. */
+#undef HAVE_SETMNTENT
+
+/* Define to 1 if you have the `setvbuf' function. */
+#undef HAVE_SETVBUF
+
+/* Define to 1 if you have the `signal' function. */
+#undef HAVE_SIGNAL
+
+/* Define to 1 if you have the <signal.h> header file. */
+#undef HAVE_SIGNAL_H
+
+/* Define it socklen_t typedef is in sys/socket.h. */
+#undef HAVE_SOCKLEN_T
+
+/* Define to 1 if you have the `stat64' function. */
+#undef HAVE_STAT64
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the `strncpy' function. */
+#undef HAVE_STRNCPY
+
+/* Define to 1 if you have the `strnlen' function. */
+#undef HAVE_STRNLEN
+
+/* Define to 1 if you have the <sys/ipc.h> header file. */
+#undef HAVE_SYS_IPC_H
+
+/* Define to 1 if you have the <sys/mman.h> header file. */
+#undef HAVE_SYS_MMAN_H
+
+/* Define to 1 if you have the <sys/sem.h> header file. */
+#undef HAVE_SYS_SEM_H
+
+/* Define to 1 if you have the <sys/shm.h> header file. */
+#undef HAVE_SYS_SHM_H
+
+/* Define to 1 if you have the <sys/socket.h> header file. */
+#undef HAVE_SYS_SOCKET_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <sys/wait.h> header file. */
+#undef HAVE_SYS_WAIT_H
+
+/* Define to 1 if the target supports thread-local storage. */
+#undef HAVE_TLS
+
+/* union semun defined in sys/ipc.h or sys/sem.h */
+#undef HAVE_UNION_SEMUN
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to 1 if you have the `__ctype_b_loc' function. */
+#undef HAVE___CTYPE_B_LOC
+
+/* Define to 1 if you have the `__ctype_tolower_loc' function. */
+#undef HAVE___CTYPE_TOLOWER_LOC
+
+/* Define to 1 if you have the `__ctype_toupper_loc' function. */
+#undef HAVE___CTYPE_TOUPPER_LOC
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* pthread_create symbol version */
+#undef PTHREAD_CREATE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION

Added: llvm-gcc-4.2/trunk/libmudflap/configure
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/configure?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/configure (added)
+++ llvm-gcc-4.2/trunk/libmudflap/configure Thu Nov  8 16:56:19 2007
@@ -0,0 +1,8635 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.59 for libmudflap 1.0.
+#
+# Copyright (C) 2003 Free Software Foundation, Inc.
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+  set -o posix
+fi
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# Support unset when possible.
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+
+# Work around bugs in pre-3.0 UWIN ksh.
+$as_unset ENV MAIL MAILPATH
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+  LC_TELEPHONE LC_TIME
+do
+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+    eval $as_var=C; export $as_var
+  else
+    $as_unset $as_var
+  fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)$' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\/\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conf$$.sh
+  echo  "exit 0"   >>conf$$.sh
+  chmod +x conf$$.sh
+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conf$$.sh
+fi
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+  # Find who we are.  Look in the path if we contain no path at all
+  # relative or not.
+  case $0 in
+    *[\\/]* ) as_myself=$0 ;;
+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+       ;;
+  esac
+  # We did not find ourselves, most probably we were run as `sh COMMAND'
+  # in which case we are not to be found in the path.
+  if test "x$as_myself" = x; then
+    as_myself=$0
+  fi
+  if test ! -f "$as_myself"; then
+    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+   { (exit 1); exit 1; }; }
+  fi
+  case $CONFIG_SHELL in
+  '')
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for as_base in sh bash ksh sh5; do
+	 case $as_dir in
+	 /*)
+	   if ("$as_dir/$as_base" -c '
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+	     CONFIG_SHELL=$as_dir/$as_base
+	     export CONFIG_SHELL
+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+	   fi;;
+	 esac
+       done
+done
+;;
+  esac
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line before each line; the second 'sed' does the real
+  # work.  The second script uses 'N' to pair each line-number line
+  # with the numbered line, and appends trailing '-' during
+  # substitution so that $LINENO is not a special case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+  sed '=' <$as_myself |
+    sed '
+      N
+      s,$,-,
+      : loop
+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      t loop
+      s,-$,,
+      s,^['$as_cr_digits']*\n,,
+    ' >$as_me.lineno &&
+  chmod +x $as_me.lineno ||
+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensible to this).
+  . ./$as_me.lineno
+  # Exit status is that of the last command.
+  exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T='	' ;;
+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+  # We could just check for DJGPP; but this test a) works b) is more generic
+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+  if test -f conf$$.exe; then
+    # Don't use ln at all; we don't have any links
+    as_ln_s='cp -p'
+  else
+    as_ln_s='ln -s'
+  fi
+elif ln conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s=ln
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.file
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p=:
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_executable_p="test -f"
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.
+as_nl='
+'
+IFS=" 	$as_nl"
+
+# CDPATH.
+$as_unset CDPATH
+
+
+# Name of the host.
+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+exec 6>&1
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_config_libobj_dir=.
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+# Maximum number of lines to put in a shell here document.
+# This variable seems obsolete.  It should probably be removed, and
+# only ac_max_sed_lines should be used.
+: ${ac_max_here_lines=38}
+
+# Identity of this package.
+PACKAGE_NAME='libmudflap'
+PACKAGE_TARNAME='libmudflap'
+PACKAGE_VERSION='1.0'
+PACKAGE_STRING='libmudflap 1.0'
+PACKAGE_BUGREPORT=''
+
+ac_unique_file="mf-runtime.c"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#if STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# if HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#if HAVE_STRING_H
+# if !STDC_HEADERS && HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os target_noncanonical INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT multi_basedir CC ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE CFLAGS CPP CPPFLAGS EGREP LN_S RANLIB ac_ct_RANLIB LIBTOOL enable_shared enab!
 le_static MF_HAVE_STDINT_H MF_HAVE_UINTPTR_T LIBMUDFLAPTH_TRUE LIBMUDFLAPTH_FALSE build_libmudflapth toolexecdir toolexeclibdir NM ac_ct_NM SECTION_FLAGS LIBOBJS LTLIBOBJS'
+ac_subst_files=''
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datadir='${prefix}/share'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+libdir='${exec_prefix}/lib'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+infodir='${prefix}/info'
+mandir='${prefix}/man'
+
+ac_prev=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval "$ac_prev=\$ac_option"
+    ac_prev=
+    continue
+  fi
+
+  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_option in
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+  | --da=*)
+    datadir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+   { (exit 1); exit 1; }; }
+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+    eval "enable_$ac_feature=no" ;;
+
+  -enable-* | --enable-*)
+    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+   { (exit 1); exit 1; }; }
+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+    case $ac_option in
+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+      *) ac_optarg=yes ;;
+    esac
+    eval "enable_$ac_feature='$ac_optarg'" ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst \
+  | --locals | --local | --loca | --loc | --lo)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid package name: $ac_package" >&2
+   { (exit 1); exit 1; }; }
+    ac_package=`echo $ac_package| sed 's/-/_/g'`
+    case $ac_option in
+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+      *) ac_optarg=yes ;;
+    esac
+    eval "with_$ac_package='$ac_optarg'" ;;
+
+  -without-* | --without-*)
+    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid package name: $ac_package" >&2
+   { (exit 1); exit 1; }; }
+    ac_package=`echo $ac_package | sed 's/-/_/g'`
+    eval "with_$ac_package=no" ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) { echo "$as_me: error: unrecognized option: $ac_option
+Try \`$0 --help' for more information." >&2
+   { (exit 1); exit 1; }; }
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+   { (exit 1); exit 1; }; }
+    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+    eval "$ac_envvar='$ac_optarg'"
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  { echo "$as_me: error: missing argument to $ac_option" >&2
+   { (exit 1); exit 1; }; }
+fi
+
+# Be sure to have absolute paths.
+for ac_var in exec_prefix prefix
+do
+  eval ac_val=$`echo $ac_var`
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+# Be sure to have absolute paths.
+for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+	      localstatedir libdir includedir oldincludedir infodir mandir
+do
+  eval ac_val=$`echo $ac_var`
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* ) ;;
+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
+    If a cross compiler is detected then cross compile mode will be used." >&2
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then its parent.
+  ac_confdir=`(dirname "$0") 2>/dev/null ||
+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$0" : 'X\(//\)[^/]' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$0" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r $srcdir/$ac_unique_file; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r $srcdir/$ac_unique_file; then
+  if test "$ac_srcdir_defaulted" = yes; then
+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+   { (exit 1); exit 1; }; }
+  else
+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+   { (exit 1); exit 1; }; }
+  fi
+fi
+(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+   { (exit 1); exit 1; }; }
+srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+ac_env_build_alias_set=${build_alias+set}
+ac_env_build_alias_value=$build_alias
+ac_cv_env_build_alias_set=${build_alias+set}
+ac_cv_env_build_alias_value=$build_alias
+ac_env_host_alias_set=${host_alias+set}
+ac_env_host_alias_value=$host_alias
+ac_cv_env_host_alias_set=${host_alias+set}
+ac_cv_env_host_alias_value=$host_alias
+ac_env_target_alias_set=${target_alias+set}
+ac_env_target_alias_value=$target_alias
+ac_cv_env_target_alias_set=${target_alias+set}
+ac_cv_env_target_alias_value=$target_alias
+ac_env_CPP_set=${CPP+set}
+ac_env_CPP_value=$CPP
+ac_cv_env_CPP_set=${CPP+set}
+ac_cv_env_CPP_value=$CPP
+ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+ac_env_CPPFLAGS_value=$CPPFLAGS
+ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures libmudflap 1.0 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+_ACEOF
+
+  cat <<_ACEOF
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+			  [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+			  [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR           user executables [EPREFIX/bin]
+  --sbindir=DIR          system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR       program executables [EPREFIX/libexec]
+  --datadir=DIR          read-only architecture-independent data [PREFIX/share]
+  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+  --libdir=DIR           object code libraries [EPREFIX/lib]
+  --includedir=DIR       C header files [PREFIX/include]
+  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+  --infodir=DIR          info documentation [PREFIX/info]
+  --mandir=DIR           man documentation [PREFIX/man]
+_ACEOF
+
+  cat <<\_ACEOF
+
+Program names:
+  --program-prefix=PREFIX            prepend PREFIX to installed program names
+  --program-suffix=SUFFIX            append SUFFIX to installed program names
+  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
+
+System types:
+  --build=BUILD     configure for building on BUILD [guessed]
+  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
+  --target=TARGET   configure for building compilers for TARGET [HOST]
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of libmudflap 1.0:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory
+  --enable-maintainer-mode  enable make rules and dependencies not useful
+			  (and sometimes confusing) to the casual installer
+  --enable-multilib       build many library versions (default)
+  --disable-dependency-tracking  speeds up one-time build
+  --enable-dependency-tracking   do not reject slow dependency extractors
+  --enable-shared=PKGS  build shared libraries default=yes
+  --enable-static=PKGS  build static libraries default=yes
+  --enable-fast-install=PKGS  optimize for fast installation default=yes
+  --disable-libtool-lock  avoid locking (might break parallel builds)
+  --enable-tls            Use thread-local storage [default=yes]
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-gnu-ld           assume the C compiler uses GNU ld default=no
+  --with-pic              try to use only PIC/non-PIC objects default=use both
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
+              headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+_ACEOF
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  ac_popdir=`pwd`
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d $ac_dir || continue
+    ac_builddir=.
+
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
+  *) # Relative path.
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+
+# Do not use `cd foo && pwd` to compute absolute paths, because
+# the directories may not exist.
+case `pwd` in
+.) ac_abs_builddir="$ac_dir";;
+*)
+  case "$ac_dir" in
+  .) ac_abs_builddir=`pwd`;;
+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_builddir=${ac_top_builddir}.;;
+*)
+  case ${ac_top_builddir}. in
+  .) ac_abs_top_builddir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_srcdir=$ac_srcdir;;
+*)
+  case $ac_srcdir in
+  .) ac_abs_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_srcdir=$ac_top_srcdir;;
+*)
+  case $ac_top_srcdir in
+  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+  esac;;
+esac
+
+    cd $ac_dir
+    # Check for guested configure; otherwise get Cygnus style configure.
+    if test -f $ac_srcdir/configure.gnu; then
+      echo
+      $SHELL $ac_srcdir/configure.gnu  --help=recursive
+    elif test -f $ac_srcdir/configure; then
+      echo
+      $SHELL $ac_srcdir/configure  --help=recursive
+    elif test -f $ac_srcdir/configure.ac ||
+	   test -f $ac_srcdir/configure.in; then
+      echo
+      $ac_configure --help
+    else
+      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi
+    cd $ac_popdir
+  done
+fi
+
+test -n "$ac_init_help" && exit 0
+if $ac_init_version; then
+  cat <<\_ACEOF
+libmudflap configure 1.0
+generated by GNU Autoconf 2.59
+
+Copyright (C) 2003 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit 0
+fi
+exec 5>config.log
+cat >&5 <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by libmudflap $as_me 1.0, which was
+generated by GNU Autoconf 2.59.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  echo "PATH: $as_dir"
+done
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_sep=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
+    2)
+      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+      # Get rid of the leading space.
+      ac_sep=" "
+      ;;
+    esac
+  done
+done
+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Be sure not to use single quotes in there, as some shells,
+# such as our DU 5.0 friend, will then `close' the trap.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    cat <<\_ASBOX
+## ---------------- ##
+## Cache variables. ##
+## ---------------- ##
+_ASBOX
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+{
+  (set) 2>&1 |
+    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+    *ac_space=\ *)
+      sed -n \
+	"s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+      ;;
+    *)
+      sed -n \
+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+      ;;
+    esac;
+}
+    echo
+
+    cat <<\_ASBOX
+## ----------------- ##
+## Output variables. ##
+## ----------------- ##
+_ASBOX
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=$`echo $ac_var`
+      echo "$ac_var='"'"'$ac_val'"'"'"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      cat <<\_ASBOX
+## ------------- ##
+## Output files. ##
+## ------------- ##
+_ASBOX
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=$`echo $ac_var`
+	echo "$ac_var='"'"'$ac_val'"'"'"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      cat <<\_ASBOX
+## ----------- ##
+## confdefs.h. ##
+## ----------- ##
+_ASBOX
+      echo
+      sed "/^$/d" confdefs.h | sort
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      echo "$as_me: caught signal $ac_signal"
+    echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core &&
+  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+     ' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -rf conftest* confdefs.h
+# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+echo >confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer explicitly selected file to automatically selected ones.
+if test -z "$CONFIG_SITE"; then
+  if test "x$prefix" != xNONE; then
+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+  else
+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+  fi
+fi
+for ac_site_file in $CONFIG_SITE; do
+  if test -r "$ac_site_file"; then
+    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file"
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special
+  # files actually), so we avoid doing that.
+  if test -f "$cache_file"; then
+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . $cache_file;;
+      *)                      . ./$cache_file;;
+    esac
+  fi
+else
+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
+echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in `(set) 2>&1 |
+	       sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+  eval ac_new_val="\$ac_env_${ac_var}_value"
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	{ echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	{ echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
+echo "$as_me:   former value:  $ac_old_val" >&2;}
+	{ echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
+echo "$as_me:   current value: $ac_new_val" >&2;}
+	ac_cache_corrupted=:
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
+echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ac_aux_dir=
+for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+  if test -f $ac_dir/install-sh; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f $ac_dir/install.sh; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f $ac_dir/shtool; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
+
+# Make sure we can run config.sub.
+$ac_config_sub sun4 >/dev/null 2>&1 ||
+  { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
+echo "$as_me: error: cannot run $ac_config_sub" >&2;}
+   { (exit 1); exit 1; }; }
+
+echo "$as_me:$LINENO: checking build system type" >&5
+echo $ECHO_N "checking build system type... $ECHO_C" >&6
+if test "${ac_cv_build+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_build_alias=$build_alias
+test -z "$ac_cv_build_alias" &&
+  ac_cv_build_alias=`$ac_config_guess`
+test -z "$ac_cv_build_alias" &&
+  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
+echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
+   { (exit 1); exit 1; }; }
+ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
+echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
+   { (exit 1); exit 1; }; }
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_build" >&5
+echo "${ECHO_T}$ac_cv_build" >&6
+build=$ac_cv_build
+build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+
+echo "$as_me:$LINENO: checking host system type" >&5
+echo $ECHO_N "checking host system type... $ECHO_C" >&6
+if test "${ac_cv_host+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_host_alias=$host_alias
+test -z "$ac_cv_host_alias" &&
+  ac_cv_host_alias=$ac_cv_build_alias
+ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
+echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
+   { (exit 1); exit 1; }; }
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_host" >&5
+echo "${ECHO_T}$ac_cv_host" >&6
+host=$ac_cv_host
+host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+
+echo "$as_me:$LINENO: checking target system type" >&5
+echo $ECHO_N "checking target system type... $ECHO_C" >&6
+if test "${ac_cv_target+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_target_alias=$target_alias
+test "x$ac_cv_target_alias" = "x" &&
+  ac_cv_target_alias=$ac_cv_host_alias
+ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
+  { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
+echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
+   { (exit 1); exit 1; }; }
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_target" >&5
+echo "${ECHO_T}$ac_cv_target" >&6
+target=$ac_cv_target
+target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+
+# The aliases save the names the user supplied, while $host etc.
+# will get canonicalized.
+test -n "$target_alias" &&
+  test "$program_prefix$program_suffix$program_transform_name" = \
+    NONENONEs,x,x, &&
+  program_prefix=${target_alias}-
+ case ${build_alias} in
+  "") build_noncanonical=${build} ;;
+  *) build_noncanonical=${build_alias} ;;
+esac
+
+ case ${host_alias} in
+  "") host_noncanonical=${build_noncanonical} ;;
+  *) host_noncanonical=${host_alias} ;;
+esac
+
+ case ${target_alias} in
+  "") target_noncanonical=${host_noncanonical} ;;
+  *) target_noncanonical=${target_alias} ;;
+esac
+
+
+
+
+am__api_version="1.9"
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
+if test -z "$INSTALL"; then
+if test "${ac_cv_path_install+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in
+  ./ | .// | /cC/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	    break 3
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+done
+
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  We don't cache a
+    # path for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the path is relative.
+    INSTALL=$ac_install_sh
+  fi
+fi
+echo "$as_me:$LINENO: result: $INSTALL" >&5
+echo "${ECHO_T}$INSTALL" >&6
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+echo "$as_me:$LINENO: checking whether build environment is sane" >&5
+echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6
+# Just in case
+sleep 1
+echo timestamp > conftest.file
+# Do `set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`
+   if test "$*" = "X"; then
+      # -L didn't work.
+      set X `ls -t $srcdir/configure conftest.file`
+   fi
+   rm -f conftest.file
+   if test "$*" != "X $srcdir/configure conftest.file" \
+      && test "$*" != "X conftest.file $srcdir/configure"; then
+
+      # If neither matched, then we have a broken ls.  This can happen
+      # if, for instance, CONFIG_SHELL is bash and it inherits a
+      # broken ls alias from the environment.  This has actually
+      # happened.  Such a system could not be considered "sane".
+      { { echo "$as_me:$LINENO: error: ls -t appears to fail.  Make sure there is not a broken
+alias in your environment" >&5
+echo "$as_me: error: ls -t appears to fail.  Make sure there is not a broken
+alias in your environment" >&2;}
+   { (exit 1); exit 1; }; }
+   fi
+
+   test "$2" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!
+Check your system clock" >&5
+echo "$as_me: error: newly created file is older than distributed files!
+Check your system clock" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+test "$program_prefix" != NONE &&
+  program_transform_name="s,^,$program_prefix,;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+  program_transform_name="s,\$,$program_suffix,;$program_transform_name"
+# Double any \ or $.  echo might interpret backslashes.
+# By default was `s,x,x', remove it if useless.
+cat <<\_ACEOF >conftest.sed
+s/[\\$]/&&/g;s/;s,x,x,$//
+_ACEOF
+program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
+rm conftest.sed
+
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+
+test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
+# Use eval to expand $SHELL
+if eval "$MISSING --run true"; then
+  am_missing_run="$MISSING --run "
+else
+  am_missing_run=
+  { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
+echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
+fi
+
+if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
+  # We used to keeping the `.' as first argument, in order to
+  # allow $(mkdir_p) to be used without argument.  As in
+  #   $(mkdir_p) $(somedir)
+  # where $(somedir) is conditionally defined.  However this is wrong
+  # for two reasons:
+  #  1. if the package is installed by a user who cannot write `.'
+  #     make install will fail,
+  #  2. the above comment should most certainly read
+  #     $(mkdir_p) $(DESTDIR)$(somedir)
+  #     so it does not work when $(somedir) is undefined and
+  #     $(DESTDIR) is not.
+  #  To support the latter case, we have to write
+  #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
+  #  so the `.' trick is pointless.
+  mkdir_p='mkdir -p --'
+else
+  # On NextStep and OpenStep, the `mkdir' command does not
+  # recognize any option.  It will interpret all options as
+  # directories to create, and then abort because `.' already
+  # exists.
+  for d in ./-p ./--version;
+  do
+    test -d $d && rmdir $d
+  done
+  # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
+  if test -f "$ac_aux_dir/mkinstalldirs"; then
+    mkdir_p='$(mkinstalldirs)'
+  else
+    mkdir_p='$(install_sh) -d'
+  fi
+fi
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_AWK+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  echo "$as_me:$LINENO: result: $AWK" >&5
+echo "${ECHO_T}$AWK" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  test -n "$AWK" && break
+done
+
+echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
+set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
+if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.make <<\_ACEOF
+all:
+	@echo 'ac_maketemp="$(MAKE)"'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering...", which would confuse us.
+eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
+if test -n "$ac_maketemp"; then
+  eval ac_cv_prog_make_${ac_make}_set=yes
+else
+  eval ac_cv_prog_make_${ac_make}_set=no
+fi
+rm -f conftest.make
+fi
+if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+  SET_MAKE=
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+
+# test to see if srcdir already configured
+if test "`cd $srcdir && pwd`" != "`pwd`" &&
+   test -f $srcdir/config.status; then
+  { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
+echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='libmudflap'
+ VERSION='1.0'
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE "$PACKAGE"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define VERSION "$VERSION"
+_ACEOF
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+install_sh=${install_sh-"$am_aux_dir/install-sh"}
+
+# Installed binaries are usually stripped using `strip' when the user
+# run `make install-strip'.  However `strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the `STRIP' environment variable to overrule this program.
+if test "$cross_compiling" != no; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_STRIP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  echo "$as_me:$LINENO: result: $STRIP" >&5
+echo "${ECHO_T}$STRIP" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+echo "${ECHO_T}$ac_ct_STRIP" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  STRIP=$ac_ct_STRIP
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
+
+# We need awk for the "check" target.  The system "awk" is bad on
+# some platforms.
+# Always define AMTAR for backward compatibility.
+
+AMTAR=${AMTAR-"${am_missing_run}tar"}
+
+am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'
+
+
+
+
+
+
+echo "$as_me:$LINENO: checking for --enable-version-specific-runtime-libs" >&5
+echo $ECHO_N "checking for --enable-version-specific-runtime-libs... $ECHO_C" >&6
+# Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
+if test "${enable_version_specific_runtime_libs+set}" = set; then
+  enableval="$enable_version_specific_runtime_libs"
+  case "$enableval" in
+ yes) version_specific_libs=yes ;;
+ no)  version_specific_libs=no ;;
+ *)   { { echo "$as_me:$LINENO: error: Unknown argument to enable/disable version-specific libs" >&5
+echo "$as_me: error: Unknown argument to enable/disable version-specific libs" >&2;}
+   { (exit 1); exit 1; }; };;
+ esac
+else
+  version_specific_libs=no
+fi;
+echo "$as_me:$LINENO: result: $version_specific_libs" >&5
+echo "${ECHO_T}$version_specific_libs" >&6
+
+echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
+echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
+    # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
+if test "${enable_maintainer_mode+set}" = set; then
+  enableval="$enable_maintainer_mode"
+  USE_MAINTAINER_MODE=$enableval
+else
+  USE_MAINTAINER_MODE=no
+fi;
+  echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
+echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
+
+
+if test $USE_MAINTAINER_MODE = yes; then
+  MAINTAINER_MODE_TRUE=
+  MAINTAINER_MODE_FALSE='#'
+else
+  MAINTAINER_MODE_TRUE='#'
+  MAINTAINER_MODE_FALSE=
+fi
+
+  MAINT=$MAINTAINER_MODE_TRUE
+
+
+
+
+# Default to --enable-multilib
+# Check whether --enable-multilib or --disable-multilib was given.
+if test "${enable_multilib+set}" = set; then
+  enableval="$enable_multilib"
+  case "$enableval" in
+  yes) multilib=yes ;;
+  no)  multilib=no ;;
+  *)   { { echo "$as_me:$LINENO: error: bad value $enableval for multilib option" >&5
+echo "$as_me: error: bad value $enableval for multilib option" >&2;}
+   { (exit 1); exit 1; }; } ;;
+ esac
+else
+  multilib=yes
+fi;
+
+# We may get other options which we leave undocumented:
+# --with-target-subdir, --with-multisrctop, --with-multisubdir
+# See config-ml.in if you want the gory details.
+
+if test "$srcdir" = "."; then
+  if test "$with_target_subdir" != "."; then
+    multi_basedir="$srcdir/$with_multisrctop../.."
+  else
+    multi_basedir="$srcdir/$with_multisrctop.."
+  fi
+else
+  multi_basedir="$srcdir/.."
+fi
+
+
+          ac_config_commands="$ac_config_commands default-1"
+
+
+target_alias=${target_alias-$host_alias}
+
+
+          ac_config_headers="$ac_config_headers config.h"
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+# The same as in boehm-gc and libstdc++. Have to borrow it from there.
+# We must force CC to /not/ be precious variables; otherwise
+# the wrong, non-multilib-adjusted value will be used in multilibs.
+# As a side effect, we have to subst CFLAGS ourselves.
+
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  CC=$ac_ct_CC
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  CC=$ac_ct_CC
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  test -n "$ac_ct_CC" && break
+done
+
+  CC=$ac_ct_CC
+fi
+
+fi
+
+
+test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&5
+echo "$as_me: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+
+# Provide some information about the compiler.
+echo "$as_me:$LINENO:" \
+     "checking for C compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+  (eval $ac_compiler --version </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+  (eval $ac_compiler -v </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+  (eval $ac_compiler -V </dev/null >&5) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+  (eval $ac_link_default) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  # Find the output, starting from the most likely.  This scheme is
+# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+# resort.
+
+# Be careful to initialize this variable, since it used to be cached.
+# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+ac_cv_exeext=
+# b.out is created by i960 compilers.
+for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+	;;
+    conftest.$ac_ext )
+	# This is the source file.
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	# FIXME: I believe we export ac_cv_exeext for Libtool,
+	# but it would be cool to find out if it's true.  Does anybody
+	# maintain Libtool? --akim.
+	export ac_cv_exeext
+	break;;
+    * )
+	break;;
+  esac
+done
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
+See \`config.log' for more details." >&5
+echo "$as_me: error: C compiler cannot create executables
+See \`config.log' for more details." >&2;}
+   { (exit 77); exit 77; }; }
+fi
+
+ac_exeext=$ac_cv_exeext
+echo "$as_me:$LINENO: result: $ac_file" >&5
+echo "${ECHO_T}$ac_file" >&6
+
+# Check the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+# If not cross compiling, check that we can run a simple program.
+if test "$cross_compiling" != yes; then
+  if { ac_try='./$ac_file'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+    fi
+  fi
+fi
+echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+
+rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+# Check the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+echo "$as_me:$LINENO: result: $cross_compiling" >&5
+echo "${ECHO_T}$cross_compiling" >&6
+
+echo "$as_me:$LINENO: checking for suffix of executables" >&5
+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  export ac_cv_exeext
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest$ac_cv_exeext
+echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+echo "${ECHO_T}$ac_cv_exeext" >&6
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+echo "$as_me:$LINENO: checking for suffix of object files" >&5
+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
+if test "${ac_cv_objext+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+echo "${ECHO_T}$ac_cv_objext" >&6
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
+if test "${ac_cv_c_compiler_gnu+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_compiler_gnu=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_compiler_gnu=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
+GCC=`test $ac_compiler_gnu = yes && echo yes`
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+CFLAGS="-g"
+echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
+if test "${ac_cv_prog_cc_g+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_prog_cc_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_prog_cc_g=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+if test "${ac_cv_prog_cc_stdc+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_prog_cc_stdc=no
+ac_save_CC=$CC
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std1 is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std1.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+# Don't try gcc -ansi; that turns off useful extensions and
+# breaks some systems' header files.
+# AIX			-qlanglvl=ansi
+# Ultrix and OSF/1	-std1
+# HP-UX 10.20 and later	-Ae
+# HP-UX older versions	-Aa -D_HPUX_SOURCE
+# SVR4			-Xc -D__EXTENSIONS__
+for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_prog_cc_stdc=$ac_arg
+break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext
+done
+rm -f conftest.$ac_ext conftest.$ac_objext
+CC=$ac_save_CC
+
+fi
+
+case "x$ac_cv_prog_cc_stdc" in
+  x|xno)
+    echo "$as_me:$LINENO: result: none needed" >&5
+echo "${ECHO_T}none needed" >&6 ;;
+  *)
+    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+    CC="$CC $ac_cv_prog_cc_stdc" ;;
+esac
+
+# Some people use a C++ compiler to compile C.  Since we use `exit',
+# in C++ we need to declare it.  In case someone uses the same compiler
+# for both compiling C and C++ we need to have the C++ compiler decide
+# the declaration of exit, since it's the most demanding environment.
+cat >conftest.$ac_ext <<_ACEOF
+#ifndef __cplusplus
+  choke me
+#endif
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  for ac_declaration in \
+   '' \
+   'extern "C" void std::exit (int) throw (); using std::exit;' \
+   'extern "C" void std::exit (int); using std::exit;' \
+   'extern "C" void exit (int) throw ();' \
+   'extern "C" void exit (int);' \
+   'void exit (int);'
+do
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_declaration
+#include <stdlib.h>
+int
+main ()
+{
+exit (42);
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+continue
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_declaration
+int
+main ()
+{
+exit (42);
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+done
+rm -f conftest*
+if test -n "$ac_declaration"; then
+  echo '#ifdef __cplusplus' >>confdefs.h
+  echo $ac_declaration      >>confdefs.h
+  echo '#endif'             >>confdefs.h
+fi
+
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+DEPDIR="${am__leading_dot}deps"
+
+          ac_config_commands="$ac_config_commands depfiles"
+
+
+am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+	@echo done
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
+echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# We grep out `Entering directory' and `Leaving directory'
+# messages which can occur if `w' ends up in MAKEFLAGS.
+# In particular we don't look at `^make:' because GNU make might
+# be invoked under some other name (usually "gmake"), in which
+# case it prints its new name instead of `make'.
+if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
+   am__include=include
+   am__quote=
+   _am_result=GNU
+fi
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+   echo '.include "confinc"' > confmf
+   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
+      am__include=.include
+      am__quote="\""
+      _am_result=BSD
+   fi
+fi
+
+
+echo "$as_me:$LINENO: result: $_am_result" >&5
+echo "${ECHO_T}$_am_result" >&6
+rm -f confinc confmf
+
+# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.
+if test "${enable_dependency_tracking+set}" = set; then
+  enableval="$enable_dependency_tracking"
+
+fi;
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+fi
+
+
+if test "x$enable_dependency_tracking" != xno; then
+  AMDEP_TRUE=
+  AMDEP_FALSE='#'
+else
+  AMDEP_TRUE='#'
+  AMDEP_FALSE=
+fi
+
+
+
+
+depcc="$CC"   am_compiler_list=
+
+echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
+echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6
+if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named `D' -- because `-MD' means `put the output
+  # in D'.
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+  fi
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
+      # Solaris 8's {/usr,}/bin/sh.
+      touch sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    case $depmode in
+    nosideeffect)
+      # after this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    none) break ;;
+    esac
+    # We check with `-c' and `-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle `-M -o', and we need to detect this.
+    if depmode=$depmode \
+       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
+echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+
+
+if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_TRUE=
+  am__fastdepCC_FALSE='#'
+else
+  am__fastdepCC_TRUE='#'
+  am__fastdepCC_FALSE=
+fi
+
+
+
+
+
+
+if test "x$GCC" != "xyes"; then
+  { { echo "$as_me:$LINENO: error: libmudflap must be built with GCC" >&5
+echo "$as_me: error: libmudflap must be built with GCC" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if test "${ac_cv_prog_CPP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether non-existent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+echo "$as_me:$LINENO: result: $CPP" >&5
+echo "${ECHO_T}$CPP" >&6
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether non-existent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  :
+else
+  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details." >&5
+echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+# Some hosts don't have dlsym(RTLD_NEXT, "symbol") for use in
+# symbol interposition.  We disable shared libraries for these.
+echo "$as_me:$LINENO: checking whether dlsym(RTLD_NEXT,...) is available" >&5
+echo $ECHO_N "checking whether dlsym(RTLD_NEXT,...) is available... $ECHO_C" >&6
+
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+#define _GNU_SOURCE
+#include <dlfcn.h>
+
+int
+main ()
+{
+void *foo = dlsym (RTLD_NEXT, "exit");
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+enable_shared=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+
+
+echo "$as_me:$LINENO: checking for egrep" >&5
+echo $ECHO_N "checking for egrep... $ECHO_C" >&6
+if test "${ac_cv_prog_egrep+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
+    then ac_cv_prog_egrep='grep -E'
+    else ac_cv_prog_egrep='egrep'
+    fi
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
+echo "${ECHO_T}$ac_cv_prog_egrep" >&6
+ EGREP=$ac_cv_prog_egrep
+
+
+echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
+if test "${ac_cv_header_stdc+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_header_stdc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_header_stdc=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then
+  :
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then
+  :
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then
+  :
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ctype.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      exit(2);
+  exit (0);
+}
+_ACEOF
+rm -f conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  :
+else
+  echo "$as_me: program exited with status $ac_status" >&5
+echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+( exit $ac_status )
+ac_cv_header_stdc=no
+fi
+rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+fi
+fi
+fi
+echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+echo "${ECHO_T}$ac_cv_header_stdc" >&6
+if test $ac_cv_header_stdc = yes; then
+
+cat >>confdefs.h <<\_ACEOF
+#define STDC_HEADERS 1
+_ACEOF
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+
+
+
+
+
+
+
+
+
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_Header=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_Header=no"
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+for ac_header in 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/mman.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_header_compiler=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <$ac_header>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+  yes:no: )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
+    ac_header_preproc=yes
+    ;;
+  no:yes:* )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+    (
+      cat <<\_ASBOX
+## ------------------------------------- ##
+## Report this to the libmudflap lists.  ##
+## ------------------------------------- ##
+_ASBOX
+    ) |
+      sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=\$ac_header_preproc"
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+
+
+
+
+for ac_func in backtrace backtrace_symbols gettimeofday signal
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+
+
+for ac_func in fopen64 fseeko64 ftello64 stat64 freopen64
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+
+for ac_func in setbuf setbuffer setlinebuf setvbuf
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+
+
+for ac_func in strnlen memrchr strncpy memmem sethostname
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+for ac_func in __ctype_b_loc __ctype_tolower_loc __ctype_toupper_loc
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+
+
+
+
+
+for ac_func in getlogin cuserid getpwnam getpwuid getpwent getgrnam getgrgid getgrent
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+
+
+for ac_func in getlogin_r getpwnam_r getpwuid_r getgrnam_r getgrgid_r
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+
+
+for ac_func in getservent getservbyname getservbyport getaddrinfo gai_strerror
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+for ac_func in getprotoent getprotobyname getprotobynumber
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+for ac_func in getmntent setmntent addmntent
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+
+
+for ac_func in inet_ntoa mmap munmap
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+int
+main ()
+{
+union semun foo;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  mf_have_semun=1
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+mf_have_semun=0
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+if test $mf_have_semun = 1
+then
+
+cat >>confdefs.h <<\_ACEOF
+#define HAVE_UNION_SEMUN 1
+_ACEOF
+
+fi
+
+
+echo "$as_me:$LINENO: checking for socklen_t in sys/socket.h" >&5
+echo $ECHO_N "checking for socklen_t in sys/socket.h... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#define _POSIX_PII_SOCKET
+#include <sys/types.h>
+#include <sys/socket.h>
+int
+main ()
+{
+socklen_t x = 5;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+
+cat >>confdefs.h <<\_ACEOF
+#define HAVE_SOCKLEN_T 1
+_ACEOF
+
+   echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+
+
+# Check whether --enable-shared or --disable-shared was given.
+if test "${enable_shared+set}" = set; then
+  enableval="$enable_shared"
+  p=${PACKAGE-default}
+case $enableval in
+yes) enable_shared=yes ;;
+no) enable_shared=no ;;
+*)
+  enable_shared=no
+  # Look at the argument we got.  We use all the common list separators.
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
+  for pkg in $enableval; do
+    if test "X$pkg" = "X$p"; then
+      enable_shared=yes
+    fi
+  done
+  IFS="$ac_save_ifs"
+  ;;
+esac
+else
+  enable_shared=yes
+fi;
+# Check whether --enable-static or --disable-static was given.
+if test "${enable_static+set}" = set; then
+  enableval="$enable_static"
+  p=${PACKAGE-default}
+case $enableval in
+yes) enable_static=yes ;;
+no) enable_static=no ;;
+*)
+  enable_static=no
+  # Look at the argument we got.  We use all the common list separators.
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
+  for pkg in $enableval; do
+    if test "X$pkg" = "X$p"; then
+      enable_static=yes
+    fi
+  done
+  IFS="$ac_save_ifs"
+  ;;
+esac
+else
+  enable_static=yes
+fi;
+# Check whether --enable-fast-install or --disable-fast-install was given.
+if test "${enable_fast_install+set}" = set; then
+  enableval="$enable_fast_install"
+  p=${PACKAGE-default}
+case $enableval in
+yes) enable_fast_install=yes ;;
+no) enable_fast_install=no ;;
+*)
+  enable_fast_install=no
+  # Look at the argument we got.  We use all the common list separators.
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
+  for pkg in $enableval; do
+    if test "X$pkg" = "X$p"; then
+      enable_fast_install=yes
+    fi
+  done
+  IFS="$ac_save_ifs"
+  ;;
+esac
+else
+  enable_fast_install=yes
+fi;
+
+# Check whether --with-gnu-ld or --without-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then
+  withval="$with_gnu_ld"
+  test "$withval" = no || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi;
+ac_prog=ld
+if test "$GCC" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
+echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [\\/]* | [A-Za-z]:[\\/]*)
+      re_direlt='/[^/][^/]*/\.\./'
+      # Canonicalize the path of ld
+      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
+      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  echo "$as_me:$LINENO: checking for GNU ld" >&5
+echo $ECHO_N "checking for GNU ld... $ECHO_C" >&6
+else
+  echo "$as_me:$LINENO: checking for non-GNU ld" >&5
+echo $ECHO_N "checking for non-GNU ld... $ECHO_C" >&6
+fi
+if test "${lt_cv_path_LD+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -z "$LD"; then
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  for ac_dir in $PATH; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some GNU ld's only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
+	test "$with_gnu_ld" != no && break
+      else
+	test "$with_gnu_ld" != yes && break
+      fi
+    fi
+  done
+  IFS="$ac_save_ifs"
+else
+  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi
+fi
+
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+  echo "$as_me:$LINENO: result: $LD" >&5
+echo "${ECHO_T}$LD" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+test -z "$LD" && { { echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
+echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
+   { (exit 1); exit 1; }; }
+echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
+echo $ECHO_N "checking if the linker ($LD) is GNU ld... $ECHO_C" >&6
+if test "${lt_cv_prog_gnu_ld+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
+if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
+  lt_cv_prog_gnu_ld=yes
+else
+  lt_cv_prog_gnu_ld=no
+fi
+fi
+echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
+echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
+echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
+if test "${lt_cv_ld_reload_flag+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_ld_reload_flag='-r'
+fi
+echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
+echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
+reload_flag=$lt_cv_ld_reload_flag
+test -n "$reload_flag" && reload_flag=" $reload_flag"
+
+echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
+echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
+if test "${lt_cv_path_NM+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM="$NM"
+else
+  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
+  for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
+    test -z "$ac_dir" && ac_dir=.
+    tmp_nm=$ac_dir/${ac_tool_prefix}nm
+    if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
+      # Check to see if the nm accepts a BSD-compat flag.
+      # Adding the `sed 1q' prevents false positives on HP-UX, which says:
+      #   nm: unknown option "B" ignored
+      # Tru64's nm complains that /dev/null is an invalid object file
+      if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
+	lt_cv_path_NM="$tmp_nm -B"
+	break
+      elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
+	lt_cv_path_NM="$tmp_nm -p"
+	break
+      else
+	lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	continue # so that we can try to find one that supports BSD flags
+      fi
+    fi
+  done
+  IFS="$ac_save_ifs"
+  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
+fi
+fi
+
+NM="$lt_cv_path_NM"
+echo "$as_me:$LINENO: result: $NM" >&5
+echo "${ECHO_T}$NM" >&6
+
+echo "$as_me:$LINENO: checking whether ln -s works" >&5
+echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+  echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+else
+  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
+echo "${ECHO_T}no, using $LN_S" >&6
+fi
+
+echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
+echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
+if test "${lt_cv_deplibs_check_method+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [regex]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given egrep regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi4*)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin* | mingw* |pw32*)
+  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  # this will be overwritten by pass_all, but leave it in just in case
+  lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  case "$host_os" in
+  rhapsody* | darwin1.012)
+    lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
+    ;;
+  *) # Darwin 1.3 on
+    lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
+    ;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | kfreebsd*-gnu)
+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20*|hpux11*)
+  case $host_cpu in
+  hppa*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
+    lt_cv_file_magic_cmd=/usr/bin/file
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
+    lt_cv_file_magic_cmd=/usr/bin/file
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  esac
+  ;;
+
+irix5* | irix6*)
+  case $host_os in
+  irix5*)
+    # this will be overridden with pass_all, but let us keep it just in case
+    lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
+    ;;
+  *)
+    case $LD in
+    *-32|*"-32 ") libmagic=32-bit;;
+    *-n32|*"-n32 ") libmagic=N32;;
+    *-64|*"-64 ") libmagic=64-bit;;
+    *) libmagic=never-match;;
+    esac
+    # this will be overridden with pass_all, but let us keep it just in case
+    lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
+    ;;
+  esac
+  lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be Linux ELF.
+linux-gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd* | knetbsd*-gnu)
+  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
+  fi
+  ;;
+
+newsos6)
+  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+osf3* | osf4* | osf5*)
+  # this will be overridden with pass_all, but let us keep it just in case
+  lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sco3.2v5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  lt_cv_file_magic_test_file=/lib/libc.so
+  ;;
+
+sysv5uw[78]* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+  case $host_vendor in
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  esac
+  ;;
+esac
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
+echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+
+
+
+# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
+
+# find the maximum length of command line arguments
+echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
+echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
+if test "${lt_cv_sys_max_cmd_len+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+    i=0
+  teststring="ABCD"
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  cygwin* | mingw*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+  esac
+
+fi
+
+if test -n "$lt_cv_sys_max_cmd_len" ; then
+  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
+echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
+else
+  echo "$as_me:$LINENO: result: none" >&5
+echo "${ECHO_T}none" >&6
+fi
+
+
+# Only perform the check for file, if the check method requires it
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
+echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $MAGIC_CMD in
+  /*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+  ?:/*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
+  ;;
+  *)
+  ac_save_MAGIC_CMD="$MAGIC_CMD"
+  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="/usr/bin:$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/${ac_tool_prefix}file; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    egrep "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool at gnu.org
+
+EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+  MAGIC_CMD="$ac_save_MAGIC_CMD"
+  ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+echo "${ECHO_T}$MAGIC_CMD" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    echo "$as_me:$LINENO: checking for file" >&5
+echo $ECHO_N "checking for file... $ECHO_C" >&6
+if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $MAGIC_CMD in
+  /*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+  ?:/*)
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
+  ;;
+  *)
+  ac_save_MAGIC_CMD="$MAGIC_CMD"
+  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="/usr/bin:$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/file; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    egrep "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool at gnu.org
+
+EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+  MAGIC_CMD="$ac_save_MAGIC_CMD"
+  ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
+echo "${ECHO_T}$MAGIC_CMD" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  else
+    MAGIC_CMD=:
+  fi
+fi
+
+  fi
+  ;;
+esac
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_RANLIB+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  echo "$as_me:$LINENO: result: $RANLIB" >&5
+echo "${ECHO_T}$RANLIB" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+echo "${ECHO_T}$ac_ct_RANLIB" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  RANLIB=$ac_ct_RANLIB
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_STRIP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  echo "$as_me:$LINENO: result: $STRIP" >&5
+echo "${ECHO_T}$STRIP" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+  test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
+echo "${ECHO_T}$ac_ct_STRIP" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  STRIP=$ac_ct_STRIP
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+
+# Check for any special flags to pass to ltconfig.
+libtool_flags="--cache-file=$cache_file"
+test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
+test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
+test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
+test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
+test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
+
+
+# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then
+  enableval="$enable_libtool_lock"
+
+fi;
+test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
+test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
+
+
+# Check whether --with-pic or --without-pic was given.
+if test "${with_pic+set}" = set; then
+  withval="$with_pic"
+  pic_mode="$withval"
+else
+  pic_mode=default
+fi;
+test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
+test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+*-*-irix6*)
+  # Find out which ABI we are using.
+  echo '#line 5852 "configure"' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+   if test "$lt_cv_prog_gnu_ld" = yes; then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -melf32bsmip"
+      ;;
+    *N32*)
+      LD="${LD-ld} -melf32bmipn32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -melf64bmip"
+      ;;
+    esac
+   else
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -32"
+      ;;
+    *N32*)
+      LD="${LD-ld} -n32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -64"
+      ;;
+    esac
+   fi
+  fi
+  rm -rf conftest*
+  ;;
+
+ia64-*-hpux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+    case "`/usr/bin/file conftest.o`" in
+    *ELF-32*)
+      HPUX_IA64_MODE="32"
+      ;;
+    *ELF-64*)
+      HPUX_IA64_MODE="64"
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+    case "`/usr/bin/file conftest.o`" in
+    *32-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_i386"
+          ;;
+        ppc64-*linux*|powerpc64-*linux*)
+          LD="${LD-ld} -m elf32ppclinux"
+          ;;
+        s390x-*linux*)
+          LD="${LD-ld} -m elf_s390"
+          ;;
+        sparc64-*linux*)
+          LD="${LD-ld} -m elf32_sparc"
+          ;;
+      esac
+      ;;
+    *64-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        ppc*-*linux*|powerpc*-*linux*)
+          LD="${LD-ld} -m elf64ppc"
+          ;;
+        s390*-*linux*)
+          LD="${LD-ld} -m elf64_s390"
+          ;;
+        sparc*-*linux*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -belf"
+  echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
+echo $ECHO_N "checking whether the C compiler needs -belf... $ECHO_C" >&6
+if test "${lt_cv_cc_needs_belf+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+
+
+     ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+     cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  lt_cv_cc_needs_belf=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+lt_cv_cc_needs_belf=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+     ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
+echo "${ECHO_T}$lt_cv_cc_needs_belf" >&6
+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS="$SAVE_CFLAGS"
+  fi
+  ;;
+
+
+esac
+
+
+# Save cache, so that ltconfig can load it
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+{
+  (set) 2>&1 |
+    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+    *ac_space=\ *)
+      # `set' does not quote correctly, so add quotes (double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \).
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;;
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n \
+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+      ;;
+    esac;
+} |
+  sed '
+     t clear
+     : clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     : end' >>confcache
+if diff $cache_file confcache >/dev/null 2>&1; then :; else
+  if test -w $cache_file; then
+    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
+    cat confcache >$cache_file
+  else
+    echo "not updating unwritable cache $cache_file"
+  fi
+fi
+rm -f confcache
+
+# Actually configure libtool.  ac_aux_dir is where install-sh is found.
+AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
+MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
+LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
+AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
+objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
+deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
+${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
+$libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
+|| { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
+echo "$as_me: error: libtool configure failed" >&2;}
+   { (exit 1); exit 1; }; }
+
+# Reload cache, that may have been modified by ltconfig
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special
+  # files actually), so we avoid doing that.
+  if test -f "$cache_file"; then
+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . $cache_file;;
+      *)                      . ./$cache_file;;
+    esac
+  fi
+else
+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
+echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+# Redirect the config.log output again, so that the ltconfig log is not
+# clobbered by the next message.
+exec 5>>./config.log
+
+
+
+
+
+
+
+
+
+if test "${ac_cv_header_stdint_h+set}" = set; then
+  echo "$as_me:$LINENO: checking for stdint.h" >&5
+echo $ECHO_N "checking for stdint.h... $ECHO_C" >&6
+if test "${ac_cv_header_stdint_h+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: $ac_cv_header_stdint_h" >&5
+echo "${ECHO_T}$ac_cv_header_stdint_h" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking stdint.h usability" >&5
+echo $ECHO_N "checking stdint.h usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+#include <stdint.h>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_header_compiler=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking stdint.h presence" >&5
+echo $ECHO_N "checking stdint.h presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdint.h>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+  yes:no: )
+    { echo "$as_me:$LINENO: WARNING: stdint.h: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: stdint.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: stdint.h: proceeding with the compiler's result" >&5
+echo "$as_me: WARNING: stdint.h: proceeding with the compiler's result" >&2;}
+    ac_header_preproc=yes
+    ;;
+  no:yes:* )
+    { echo "$as_me:$LINENO: WARNING: stdint.h: present but cannot be compiled" >&5
+echo "$as_me: WARNING: stdint.h: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: stdint.h:     check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: stdint.h:     check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: stdint.h: see the Autoconf documentation" >&5
+echo "$as_me: WARNING: stdint.h: see the Autoconf documentation" >&2;}
+    { echo "$as_me:$LINENO: WARNING: stdint.h:     section \"Present But Cannot Be Compiled\"" >&5
+echo "$as_me: WARNING: stdint.h:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { echo "$as_me:$LINENO: WARNING: stdint.h: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: stdint.h: proceeding with the preprocessor's result" >&2;}
+    { echo "$as_me:$LINENO: WARNING: stdint.h: in the future, the compiler will take precedence" >&5
+echo "$as_me: WARNING: stdint.h: in the future, the compiler will take precedence" >&2;}
+    (
+      cat <<\_ASBOX
+## ------------------------------------- ##
+## Report this to the libmudflap lists.  ##
+## ------------------------------------- ##
+_ASBOX
+    ) |
+      sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+echo "$as_me:$LINENO: checking for stdint.h" >&5
+echo $ECHO_N "checking for stdint.h... $ECHO_C" >&6
+if test "${ac_cv_header_stdint_h+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_header_stdint_h=$ac_header_preproc
+fi
+echo "$as_me:$LINENO: result: $ac_cv_header_stdint_h" >&5
+echo "${ECHO_T}$ac_cv_header_stdint_h" >&6
+
+fi
+if test $ac_cv_header_stdint_h = yes; then
+  MF_HAVE_STDINT_H=1
+else
+  MF_HAVE_STDINT_H=0
+fi
+
+
+
+if test $MF_HAVE_STDINT_H = 1
+then
+   MF_HAVE_UINTPTR_T=1
+else
+   cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <sys/types.h>
+int
+main ()
+{
+uintptr_t k = 0;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  MF_HAVE_UINTPTR_T=1
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+MF_HAVE_UINTPTR_T=0
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+
+
+if test ! -d pth
+then
+  # libmudflapth objects are built in this subdirectory
+  mkdir pth
+fi
+
+
+for ac_header in pthread.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+else
+  # Is the header compilable?
+echo "$as_me:$LINENO: checking $ac_header usability" >&5
+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_header_compiler=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6
+
+# Is the header present?
+echo "$as_me:$LINENO: checking $ac_header presence" >&5
+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <$ac_header>
+_ACEOF
+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null; then
+  if test -s conftest.err; then
+    ac_cpp_err=$ac_c_preproc_warn_flag
+    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
+  else
+    ac_cpp_err=
+  fi
+else
+  ac_cpp_err=yes
+fi
+if test -z "$ac_cpp_err"; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.$ac_ext
+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+  yes:no: )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
+    ac_header_preproc=yes
+    ;;
+  no:yes:* )
+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
+echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
+echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
+    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
+echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
+    (
+      cat <<\_ASBOX
+## ------------------------------------- ##
+## Report this to the libmudflap lists.  ##
+## ------------------------------------- ##
+_ASBOX
+    ) |
+      sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
+if eval "test \"\${$as_ac_Header+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  eval "$as_ac_Header=\$ac_header_preproc"
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
+
+fi
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+echo "$as_me:$LINENO: checking for thread model used by GCC" >&5
+echo $ECHO_N "checking for thread model used by GCC... $ECHO_C" >&6
+target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
+echo "$as_me:$LINENO: result: $target_thread_file" >&5
+echo "${ECHO_T}$target_thread_file" >&6
+
+# We only support posix threads, or no threads at all.
+posix_threads=
+case ${target_thread_file} in
+  posix)
+    posix_threads=yes
+    ;;
+  single)
+    ;;
+  *)
+    echo "${target_thread_file} is an unsupported thread package" 1>&2
+    exit 1
+    ;;
+esac
+
+
+
+if test "x$posix_threads" != "x"; then
+  LIBMUDFLAPTH_TRUE=
+  LIBMUDFLAPTH_FALSE='#'
+else
+  LIBMUDFLAPTH_TRUE='#'
+  LIBMUDFLAPTH_FALSE=
+fi
+
+if test "x$posix_threads" != "x"
+then
+        build_libmudflapth=1
+else
+        build_libmudflapth=0
+fi
+
+
+
+echo "$as_me:$LINENO: checking for dlsym in -ldl" >&5
+echo $ECHO_N "checking for dlsym in -ldl... $ECHO_C" >&6
+if test "${ac_cv_lib_dl_dlsym+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char dlsym ();
+int
+main ()
+{
+dlsym ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_cv_lib_dl_dlsym=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_lib_dl_dlsym=no
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlsym" >&5
+echo "${ECHO_T}$ac_cv_lib_dl_dlsym" >&6
+if test $ac_cv_lib_dl_dlsym = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_LIBDL 1
+_ACEOF
+
+  LIBS="-ldl $LIBS"
+
+fi
+
+
+# Calculate toolexeclibdir
+# Also toolexecdir, though it's only used in toolexeclibdir
+case ${version_specific_libs} in
+  yes)
+    # Need the gcc compiler version to know where to install libraries
+    # and header files if --enable-version-specific-runtime-libs option
+    # is selected.
+    toolexecdir='$(libdir)/gcc/$(target_alias)'
+    toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
+    ;;
+  no)
+    if test -n "$with_cross_host" &&
+       test x"$with_cross_host" != x"no"; then
+      # Install a library built with a cross compiler in tooldir, not libdir.
+      toolexecdir='$(exec_prefix)/$(target_alias)'
+      toolexeclibdir='$(toolexecdir)/lib'
+    else
+      toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
+      toolexeclibdir='$(libdir)'
+    fi
+    multi_os_directory=`$CC -print-multi-os-directory`
+    case $multi_os_directory in
+      .) ;; # Avoid trailing /.
+      *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
+    esac
+    ;;
+esac
+
+
+
+includedir=${toolexecdir}/include
+
+
+pthread_create_version='""'
+if test "x$enable_shared" = "xyes" && test "x$posix_threads" != "x"; then
+  # NB: don't check for -lpthread here, because then it would be
+  # added to LIBS.  For the thread-unaware libmudflap.la, we don't
+  # want it there.
+
+  # glibc-related hacks.  dlsym() may pick the wrong version of
+  # interposed functions like pthread_create on modern glibc.
+  # We need to find the proper symbol version string, and use
+  # the nonstandard dlvsym().
+
+for ac_func in dlvsym
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any gcc2 internal prototype to avoid an error.  */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+   builtin and then its argument prototype would still apply.  */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}nm", so it can be a program name with args.
+set dummy ${ac_tool_prefix}nm; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_NM+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$NM"; then
+  ac_cv_prog_NM="$NM" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_NM="${ac_tool_prefix}nm"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+NM=$ac_cv_prog_NM
+if test -n "$NM"; then
+  echo "$as_me:$LINENO: result: $NM" >&5
+echo "${ECHO_T}$NM" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_NM"; then
+  ac_ct_NM=$NM
+  # Extract the first word of "nm", so it can be a program name with args.
+set dummy nm; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_NM+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_NM"; then
+  ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_NM="nm"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+
+fi
+fi
+ac_ct_NM=$ac_cv_prog_ac_ct_NM
+if test -n "$ac_ct_NM"; then
+  echo "$as_me:$LINENO: result: $ac_ct_NM" >&5
+echo "${ECHO_T}$ac_ct_NM" >&6
+else
+  echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+  NM=$ac_ct_NM
+else
+  NM="$ac_cv_prog_NM"
+fi
+
+  if test "x$ac_cv_have_dlvsym" != "x"; then
+    # Try compiling a simple pthreads program.  Find the shared libraries it
+    # ends up with.  Then use "nm" on those libraries to extract the
+    # default symbol versioning suffix ("@@"), if any.  But that's tricky.
+    # Rather, run nm on the resulting executable.  Unfortunately, autoconf
+    # doesn't appear to have a macro that builds a test executable for
+    # subsequent analysis ... so we do it by hand here.
+    cat >> conftest.c << EOF
+#include <pthread.h>
+int main () { void *p = (void *) & pthread_create; return (int) p; }
+EOF
+    oldLIBS="$LIBS"
+    LIBS="$LIBS -lpthread"
+    pthread_create_version="\"\""
+    echo "$as_me:$LINENO: checking pthread_create symbol version" >&5
+echo $ECHO_N "checking pthread_create symbol version... $ECHO_C" >&6
+    if eval $ac_link 2>&5 && test -s conftest${ac_exeext}; then
+      version=`$NM conftest${ac_exeect} | grep 'pthread_create@@' | sed -e 's/^.*@@//'`
+      if test "x$version" != "x"; then
+        pthread_create_version="\"$version\""
+      fi
+    fi
+    echo "$as_me:$LINENO: result: $pthread_create_version" >&5
+echo "${ECHO_T}$pthread_create_version" >&6
+    LIBS="$oldLIBS"
+  fi
+fi
+
+cat >>confdefs.h <<_ACEOF
+#define PTHREAD_CREATE_VERSION $pthread_create_version
+_ACEOF
+
+
+
+# Figure out whether the compiler supports "-ffunction-sections -fdata-sections",
+# similarly to how libstdc++ does it
+ac_test_CFLAGS="${CFLAGS+set}"
+ac_save_CFLAGS="$CFLAGS"
+
+# Check for -ffunction-sections -fdata-sections
+echo "$as_me:$LINENO: checking for gcc that supports -ffunction-sections -fdata-sections" >&5
+echo $ECHO_N "checking for gcc that supports -ffunction-sections -fdata-sections... $ECHO_C" >&6
+CFLAGS='-Werror -ffunction-sections -fdata-sections'
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+int foo;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  ac_fdsections=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_fdsections=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS="$ac_save_CFLAGS"
+else
+  # this is the suspicious part
+  CFLAGS=""
+fi
+if test x"$ac_fdsections" = x"yes"; then
+  SECTION_FLAGS='-ffunction-sections -fdata-sections'
+fi
+echo "$as_me:$LINENO: result: $ac_fdsections" >&5
+echo "${ECHO_T}$ac_fdsections" >&6
+
+
+
+# Check for the name of the symbol used for the entry point.
+echo "$as_me:$LINENO: checking for the name of the symbol used for the entry point" >&5
+echo $ECHO_N "checking for the name of the symbol used for the entry point... $ECHO_C" >&6
+if test "${mudflap_cv_entry_point+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+
+for name in _start __start unknown; do
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+extern char $name[];
+int
+main ()
+{
+$name[0] = 0;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  break
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+done
+mudflap_cv_entry_point="$name"
+fi
+echo "$as_me:$LINENO: result: $mudflap_cv_entry_point" >&5
+echo "${ECHO_T}$mudflap_cv_entry_point" >&6
+if test "$mudflap_cv_entry_point" = unknown; then
+  { { echo "$as_me:$LINENO: error: none of the known symbol names works" >&5
+echo "$as_me: error: none of the known symbol names works" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+cat >>confdefs.h <<_ACEOF
+#define ENTRY_POINT $mudflap_cv_entry_point
+_ACEOF
+
+
+
+if test ${multilib} = yes; then
+  multilib_arg="--enable-multilib"
+else
+  multilib_arg=
+fi
+
+# See if we support thread-local storage.
+
+   # Check whether --enable-tls or --disable-tls was given.
+if test "${enable_tls+set}" = set; then
+  enableval="$enable_tls"
+
+      case "$enableval" in
+       yes|no) ;;
+       *) { { echo "$as_me:$LINENO: error: Argument to enable/disable tls must be yes or no" >&5
+echo "$as_me: error: Argument to enable/disable tls must be yes or no" >&2;}
+   { (exit 1); exit 1; }; } ;;
+      esac
+
+else
+  enable_tls=yes
+fi;
+
+  echo "$as_me:$LINENO: checking whether the target supports thread-local storage" >&5
+echo $ECHO_N "checking whether the target supports thread-local storage... $ECHO_C" >&6
+if test "${have_tls+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+
+    if test "$cross_compiling" = yes; then
+  cat >conftest.$ac_ext <<_ACEOF
+__thread int foo;
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+  (eval $ac_compile) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest.$ac_objext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  have_tls=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+have_tls=no
+fi
+rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
+
+else
+  cat >conftest.$ac_ext <<_ACEOF
+__thread int a; int b; int main() { return a = b; }
+_ACEOF
+rm -f conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+                      save_LDFLAGS="$LDFLAGS"
+      LDFLAGS="-static $LDFLAGS"
+      cat >conftest.$ac_ext <<_ACEOF
+int main() { return 0; }
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } &&
+	 { ac_try='test -z "$ac_c_werror_flag"
+			 || test ! -s conftest.err'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; } &&
+	 { ac_try='test -s conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  if test "$cross_compiling" = yes; then
+  { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot run test program while cross compiling
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+else
+  cat >conftest.$ac_ext <<_ACEOF
+__thread int a; int b; int main() { return a = b; }
+_ACEOF
+rm -f conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  have_tls=yes
+else
+  echo "$as_me: program exited with status $ac_status" >&5
+echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+( exit $ac_status )
+have_tls=no
+fi
+rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+fi
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+have_tls=yes
+fi
+rm -f conftest.err conftest.$ac_objext \
+      conftest$ac_exeext conftest.$ac_ext
+      LDFLAGS="$save_LDFLAGS"
+else
+  echo "$as_me: program exited with status $ac_status" >&5
+echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+( exit $ac_status )
+have_tls=no
+fi
+rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+fi
+fi
+echo "$as_me:$LINENO: result: $have_tls" >&5
+echo "${ECHO_T}$have_tls" >&6
+  if test "$enable_tls $have_tls" = "yes yes"; then
+
+cat >>confdefs.h <<\_ACEOF
+#define HAVE_TLS 1
+_ACEOF
+
+  fi
+
+                              ac_config_files="$ac_config_files Makefile testsuite/Makefile testsuite/mfconfig.exp"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+{
+  (set) 2>&1 |
+    case `(ac_space=' '; set | grep ac_space) 2>&1` in
+    *ac_space=\ *)
+      # `set' does not quote correctly, so add quotes (double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \).
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;;
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n \
+	"s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+      ;;
+    esac;
+} |
+  sed '
+     t clear
+     : clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     : end' >>confcache
+if diff $cache_file confcache >/dev/null 2>&1; then :; else
+  if test -w $cache_file; then
+    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
+    cat confcache >$cache_file
+  else
+    echo "not updating unwritable cache $cache_file"
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# VPATH may cause trouble with some makes, so we remove $(srcdir),
+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{
+s/:*\$(srcdir):*/:/;
+s/:*\${srcdir}:*/:/;
+s/:*@srcdir@:*/:/;
+s/^\([^=]*=[	 ]*\):*/\1/;
+s/:*$//;
+s/^[^=]*=[	 ]*$//;
+}'
+fi
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_i=`echo "$ac_i" |
+	 sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+  # 2. Add them.
+  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
+  { { echo "$as_me:$LINENO: error: conditional \"MAINTAINER_MODE\" was never defined.
+Usually this means the macro was only invoked conditionally." >&5
+echo "$as_me: error: conditional \"MAINTAINER_MODE\" was never defined.
+Usually this means the macro was only invoked conditionally." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+  { { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." >&5
+echo "$as_me: error: conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  { { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." >&5
+echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+if test -z "${LIBMUDFLAPTH_TRUE}" && test -z "${LIBMUDFLAPTH_FALSE}"; then
+  { { echo "$as_me:$LINENO: error: conditional \"LIBMUDFLAPTH\" was never defined.
+Usually this means the macro was only invoked conditionally." >&5
+echo "$as_me: error: conditional \"LIBMUDFLAPTH\" was never defined.
+Usually this means the macro was only invoked conditionally." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+: ${CONFIG_STATUS=./config.status}
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
+echo "$as_me: creating $CONFIG_STATUS" >&6;}
+cat >$CONFIG_STATUS <<_ACEOF
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+SHELL=\${CONFIG_SHELL-$SHELL}
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+  set -o posix
+fi
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# Support unset when possible.
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+
+# Work around bugs in pre-3.0 UWIN ksh.
+$as_unset ENV MAIL MAILPATH
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+  LC_TELEPHONE LC_TIME
+do
+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+    eval $as_var=C; export $as_var
+  else
+    $as_unset $as_var
+  fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)$' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\/\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conf$$.sh
+  echo  "exit 0"   >>conf$$.sh
+  chmod +x conf$$.sh
+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conf$$.sh
+fi
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {
+  # Find who we are.  Look in the path if we contain no path at all
+  # relative or not.
+  case $0 in
+    *[\\/]* ) as_myself=$0 ;;
+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+       ;;
+  esac
+  # We did not find ourselves, most probably we were run as `sh COMMAND'
+  # in which case we are not to be found in the path.
+  if test "x$as_myself" = x; then
+    as_myself=$0
+  fi
+  if test ! -f "$as_myself"; then
+    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+   { (exit 1); exit 1; }; }
+  fi
+  case $CONFIG_SHELL in
+  '')
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for as_base in sh bash ksh sh5; do
+	 case $as_dir in
+	 /*)
+	   if ("$as_dir/$as_base" -c '
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+	     CONFIG_SHELL=$as_dir/$as_base
+	     export CONFIG_SHELL
+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+	   fi;;
+	 esac
+       done
+done
+;;
+  esac
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line before each line; the second 'sed' does the real
+  # work.  The second script uses 'N' to pair each line-number line
+  # with the numbered line, and appends trailing '-' during
+  # substitution so that $LINENO is not a special case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
+  sed '=' <$as_myself |
+    sed '
+      N
+      s,$,-,
+      : loop
+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+      t loop
+      s,-$,,
+      s,^['$as_cr_digits']*\n,,
+    ' >$as_me.lineno &&
+  chmod +x $as_me.lineno ||
+    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensible to this).
+  . ./$as_me.lineno
+  # Exit status is that of the last command.
+  exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T='	' ;;
+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+  # We could just check for DJGPP; but this test a) works b) is more generic
+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+  if test -f conf$$.exe; then
+    # Don't use ln at all; we don't have any links
+    as_ln_s='cp -p'
+  else
+    as_ln_s='ln -s'
+  fi
+elif ln conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s=ln
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.file
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p=:
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_executable_p="test -f"
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.
+as_nl='
+'
+IFS=" 	$as_nl"
+
+# CDPATH.
+$as_unset CDPATH
+
+exec 6>&1
+
+# Open the log real soon, to keep \$[0] and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.  Logging --version etc. is OK.
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+} >&5
+cat >&5 <<_CSEOF
+
+This file was extended by libmudflap $as_me 1.0, which was
+generated by GNU Autoconf 2.59.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+_CSEOF
+echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+echo >&5
+_ACEOF
+
+# Files that config.status was made for.
+if test -n "$ac_config_files"; then
+  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_headers"; then
+  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_links"; then
+  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_commands"; then
+  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+ac_cs_usage="\
+\`$as_me' instantiates files from templates according to the
+current configuration.
+
+Usage: $0 [OPTIONS] [FILE]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number, then exit
+  -q, --quiet      do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+  --file=FILE[:TEMPLATE]
+		   instantiate the configuration file FILE
+  --header=FILE[:TEMPLATE]
+		   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Configuration commands:
+$config_commands
+
+Report bugs to <bug-autoconf at gnu.org>."
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+ac_cs_version="\\
+libmudflap config.status 1.0
+configured by $0, generated by GNU Autoconf 2.59,
+  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
+
+Copyright (C) 2003 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+srcdir=$srcdir
+INSTALL="$INSTALL"
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+# If no file are specified by the user, then we need to provide default
+# value.  By we need to know if files were specified by the user.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=*)
+    ac_option=`expr "x$1" : 'x\([^=]*\)='`
+    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  -*)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  *) # This is not an option, so the user has probably given explicit
+     # arguments.
+     ac_option=$1
+     ac_need_defaults=false;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --vers* | -V )
+    echo "$ac_cs_version"; exit 0 ;;
+  --he | --h)
+    # Conflict between --help and --header
+    { { echo "$as_me:$LINENO: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&2;}
+   { (exit 1); exit 1; }; };;
+  --help | --hel | -h )
+    echo "$ac_cs_usage"; exit 0 ;;
+  --debug | --d* | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+    ac_need_defaults=false;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&2;}
+   { (exit 1); exit 1; }; } ;;
+
+  *) ac_config_targets="$ac_config_targets $1" ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+if \$ac_cs_recheck; then
+  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+fi
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+#
+# INIT-COMMANDS section.
+#
+
+
+srcdir="$srcdir"
+host="$host"
+target="$target"
+with_multisubdir="$with_multisubdir"
+with_multisrctop="$with_multisrctop"
+with_target_subdir="$with_target_subdir"
+ac_configure_args="${multilib_arg} ${ac_configure_args}"
+multi_basedir="$multi_basedir"
+CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+CC="$CC"
+AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+
+_ACEOF
+
+
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+for ac_config_target in $ac_config_targets
+do
+  case "$ac_config_target" in
+  # Handling of arguments.
+  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+  "testsuite/Makefile" ) CONFIG_FILES="$CONFIG_FILES testsuite/Makefile" ;;
+  "testsuite/mfconfig.exp" ) CONFIG_FILES="$CONFIG_FILES testsuite/mfconfig.exp" ;;
+  "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
+  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
+  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason to put it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Create a temporary directory, and hook for its removal unless debugging.
+$debug ||
+{
+  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
+  trap '{ (exit 1); exit 1; }' 1 2 13 15
+}
+
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
+  test -n "$tmp" && test -d "$tmp"
+}  ||
+{
+  tmp=./confstat$$-$RANDOM
+  (umask 077 && mkdir $tmp)
+} ||
+{
+   echo "$me: cannot create a temporary directory in ." >&2
+   { (exit 1); exit 1; }
+}
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+
+#
+# CONFIG_FILES section.
+#
+
+# No need to generate the scripts if there are no CONFIG_FILES.
+# This happens for instance when ./config.status config.h
+if test -n "\$CONFIG_FILES"; then
+  # Protect against being on the right side of a sed subst in config.status.
+  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+s, at SHELL@,$SHELL,;t t
+s, at PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+s, at PACKAGE_NAME@,$PACKAGE_NAME,;t t
+s, at PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+s, at PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+s, at PACKAGE_STRING@,$PACKAGE_STRING,;t t
+s, at PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+s, at exec_prefix@,$exec_prefix,;t t
+s, at prefix@,$prefix,;t t
+s, at program_transform_name@,$program_transform_name,;t t
+s, at bindir@,$bindir,;t t
+s, at sbindir@,$sbindir,;t t
+s, at libexecdir@,$libexecdir,;t t
+s, at datadir@,$datadir,;t t
+s, at sysconfdir@,$sysconfdir,;t t
+s, at sharedstatedir@,$sharedstatedir,;t t
+s, at localstatedir@,$localstatedir,;t t
+s, at libdir@,$libdir,;t t
+s, at includedir@,$includedir,;t t
+s, at oldincludedir@,$oldincludedir,;t t
+s, at infodir@,$infodir,;t t
+s, at mandir@,$mandir,;t t
+s, at build_alias@,$build_alias,;t t
+s, at host_alias@,$host_alias,;t t
+s, at target_alias@,$target_alias,;t t
+s, at DEFS@,$DEFS,;t t
+s, at ECHO_C@,$ECHO_C,;t t
+s, at ECHO_N@,$ECHO_N,;t t
+s, at ECHO_T@,$ECHO_T,;t t
+s, at LIBS@,$LIBS,;t t
+s, at build@,$build,;t t
+s, at build_cpu@,$build_cpu,;t t
+s, at build_vendor@,$build_vendor,;t t
+s, at build_os@,$build_os,;t t
+s, at host@,$host,;t t
+s, at host_cpu@,$host_cpu,;t t
+s, at host_vendor@,$host_vendor,;t t
+s, at host_os@,$host_os,;t t
+s, at target@,$target,;t t
+s, at target_cpu@,$target_cpu,;t t
+s, at target_vendor@,$target_vendor,;t t
+s, at target_os@,$target_os,;t t
+s, at target_noncanonical@,$target_noncanonical,;t t
+s, at INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+s, at INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+s, at INSTALL_DATA@,$INSTALL_DATA,;t t
+s, at CYGPATH_W@,$CYGPATH_W,;t t
+s, at PACKAGE@,$PACKAGE,;t t
+s, at VERSION@,$VERSION,;t t
+s, at ACLOCAL@,$ACLOCAL,;t t
+s, at AUTOCONF@,$AUTOCONF,;t t
+s, at AUTOMAKE@,$AUTOMAKE,;t t
+s, at AUTOHEADER@,$AUTOHEADER,;t t
+s, at MAKEINFO@,$MAKEINFO,;t t
+s, at install_sh@,$install_sh,;t t
+s, at STRIP@,$STRIP,;t t
+s, at ac_ct_STRIP@,$ac_ct_STRIP,;t t
+s, at INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t
+s, at mkdir_p@,$mkdir_p,;t t
+s, at AWK@,$AWK,;t t
+s, at SET_MAKE@,$SET_MAKE,;t t
+s, at am__leading_dot@,$am__leading_dot,;t t
+s, at AMTAR@,$AMTAR,;t t
+s, at am__tar@,$am__tar,;t t
+s, at am__untar@,$am__untar,;t t
+s, at MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
+s, at MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
+s, at MAINT@,$MAINT,;t t
+s, at multi_basedir@,$multi_basedir,;t t
+s, at CC@,$CC,;t t
+s, at ac_ct_CC@,$ac_ct_CC,;t t
+s, at EXEEXT@,$EXEEXT,;t t
+s, at OBJEXT@,$OBJEXT,;t t
+s, at DEPDIR@,$DEPDIR,;t t
+s, at am__include@,$am__include,;t t
+s, at am__quote@,$am__quote,;t t
+s, at AMDEP_TRUE@,$AMDEP_TRUE,;t t
+s, at AMDEP_FALSE@,$AMDEP_FALSE,;t t
+s, at AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t
+s, at CCDEPMODE@,$CCDEPMODE,;t t
+s, at am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t
+s, at am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t
+s, at CFLAGS@,$CFLAGS,;t t
+s, at CPP@,$CPP,;t t
+s, at CPPFLAGS@,$CPPFLAGS,;t t
+s, at EGREP@,$EGREP,;t t
+s, at LN_S@,$LN_S,;t t
+s, at RANLIB@,$RANLIB,;t t
+s, at ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+s, at LIBTOOL@,$LIBTOOL,;t t
+s, at enable_shared@,$enable_shared,;t t
+s, at enable_static@,$enable_static,;t t
+s, at MF_HAVE_STDINT_H@,$MF_HAVE_STDINT_H,;t t
+s, at MF_HAVE_UINTPTR_T@,$MF_HAVE_UINTPTR_T,;t t
+s, at LIBMUDFLAPTH_TRUE@,$LIBMUDFLAPTH_TRUE,;t t
+s, at LIBMUDFLAPTH_FALSE@,$LIBMUDFLAPTH_FALSE,;t t
+s, at build_libmudflapth@,$build_libmudflapth,;t t
+s, at toolexecdir@,$toolexecdir,;t t
+s, at toolexeclibdir@,$toolexeclibdir,;t t
+s, at NM@,$NM,;t t
+s, at ac_ct_NM@,$ac_ct_NM,;t t
+s, at SECTION_FLAGS@,$SECTION_FLAGS,;t t
+s, at LIBOBJS@,$LIBOBJS,;t t
+s, at LTLIBOBJS@,$LTLIBOBJS,;t t
+CEOF
+
+_ACEOF
+
+  cat >>$CONFIG_STATUS <<\_ACEOF
+  # Split the substitutions into bite-sized pieces for seds with
+  # small command number limits, like on Digital OSF/1 and HP-UX.
+  ac_max_sed_lines=48
+  ac_sed_frag=1 # Number of current file.
+  ac_beg=1 # First line for current file.
+  ac_end=$ac_max_sed_lines # Line after last line for current file.
+  ac_more_lines=:
+  ac_sed_cmds=
+  while $ac_more_lines; do
+    if test $ac_beg -gt 1; then
+      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+    else
+      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+    fi
+    if test ! -s $tmp/subs.frag; then
+      ac_more_lines=false
+    else
+      # The purpose of the label and of the branching condition is to
+      # speed up the sed processing (if there are no `@' at all, there
+      # is no need to browse any of the substitutions).
+      # These are the two extra sed commands mentioned above.
+      (echo ':t
+  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+      if test -z "$ac_sed_cmds"; then
+	ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+      else
+	ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+      fi
+      ac_sed_frag=`expr $ac_sed_frag + 1`
+      ac_beg=$ac_end
+      ac_end=`expr $ac_end + $ac_max_sed_lines`
+    fi
+  done
+  if test -z "$ac_sed_cmds"; then
+    ac_sed_cmds=cat
+  fi
+fi # test -n "$CONFIG_FILES"
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case $ac_file in
+  - | *:- | *:-:* ) # input from stdin
+	cat >$tmp/stdin
+	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  * )   ac_file_in=$ac_file.in ;;
+  esac
+
+  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+  ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+  { if $as_mkdir_p; then
+    mkdir -p "$ac_dir"
+  else
+    as_dir="$ac_dir"
+    as_dirs=
+    while test ! -d "$as_dir"; do
+      as_dirs="$as_dir $as_dirs"
+      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+    done
+    test ! -n "$as_dirs" || mkdir $as_dirs
+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+   { (exit 1); exit 1; }; }; }
+
+  ac_builddir=.
+
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
+  *) # Relative path.
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+
+# Do not use `cd foo && pwd` to compute absolute paths, because
+# the directories may not exist.
+case `pwd` in
+.) ac_abs_builddir="$ac_dir";;
+*)
+  case "$ac_dir" in
+  .) ac_abs_builddir=`pwd`;;
+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_builddir=${ac_top_builddir}.;;
+*)
+  case ${ac_top_builddir}. in
+  .) ac_abs_top_builddir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_srcdir=$ac_srcdir;;
+*)
+  case $ac_srcdir in
+  .) ac_abs_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_srcdir=$ac_top_srcdir;;
+*)
+  case $ac_top_srcdir in
+  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+  esac;;
+esac
+
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
+  esac
+
+  if test x"$ac_file" != x-; then
+    { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+    rm -f "$ac_file"
+  fi
+  # Let's still pretend it is `configure' which instantiates (i.e., don't
+  # use $as_me), people would be surprised to read:
+  #    /* config.h.  Generated by config.status.  */
+  if test x"$ac_file" = x-; then
+    configure_input=
+  else
+    configure_input="$ac_file.  "
+  fi
+  configure_input=$configure_input"Generated from `echo $ac_file_in |
+				     sed 's,.*/,,'` by configure."
+
+  # First look for the input files in the build tree, otherwise in the
+  # src tree.
+  ac_file_inputs=`IFS=:
+    for f in $ac_file_in; do
+      case $f in
+      -) echo $tmp/stdin ;;
+      [\\/$]*)
+	 # Absolute (can't be DOS-style, as IFS=:)
+	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 echo "$f";;
+      *) # Relative
+	 if test -f "$f"; then
+	   # Build tree
+	   echo "$f"
+	 elif test -f "$srcdir/$f"; then
+	   # Source tree
+	   echo "$srcdir/$f"
+	 else
+	   # /dev/null tree
+	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 fi;;
+      esac
+    done` || { (exit 1); exit 1; }
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+  sed "$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s, at configure_input@,$configure_input,;t t
+s, at srcdir@,$ac_srcdir,;t t
+s, at abs_srcdir@,$ac_abs_srcdir,;t t
+s, at top_srcdir@,$ac_top_srcdir,;t t
+s, at abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+s, at builddir@,$ac_builddir,;t t
+s, at abs_builddir@,$ac_abs_builddir,;t t
+s, at top_builddir@,$ac_top_builddir,;t t
+s, at abs_top_builddir@,$ac_abs_top_builddir,;t t
+s, at INSTALL@,$ac_INSTALL,;t t
+" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+  rm -f $tmp/stdin
+  if test x"$ac_file" != x-; then
+    mv $tmp/out $ac_file
+  else
+    cat $tmp/out
+    rm -f $tmp/out
+  fi
+
+done
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+#
+# CONFIG_HEADER section.
+#
+
+# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+# NAME is the cpp macro being defined and VALUE is the value it is being given.
+#
+# ac_d sets the value in "#define NAME VALUE" lines.
+ac_dA='s,^\([	 ]*\)#\([	 ]*define[	 ][	 ]*\)'
+ac_dB='[	 ].*$,\1#\2'
+ac_dC=' '
+ac_dD=',;t'
+# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+ac_uA='s,^\([	 ]*\)#\([	 ]*\)undef\([	 ][	 ]*\)'
+ac_uB='$,\1#\2define\3'
+ac_uC=' '
+ac_uD=',;t'
+
+for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+  case $ac_file in
+  - | *:- | *:-:* ) # input from stdin
+	cat >$tmp/stdin
+	ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+	ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+  * )   ac_file_in=$ac_file.in ;;
+  esac
+
+  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+
+  # First look for the input files in the build tree, otherwise in the
+  # src tree.
+  ac_file_inputs=`IFS=:
+    for f in $ac_file_in; do
+      case $f in
+      -) echo $tmp/stdin ;;
+      [\\/$]*)
+	 # Absolute (can't be DOS-style, as IFS=:)
+	 test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 # Do quote $f, to prevent DOS paths from being IFS'd.
+	 echo "$f";;
+      *) # Relative
+	 if test -f "$f"; then
+	   # Build tree
+	   echo "$f"
+	 elif test -f "$srcdir/$f"; then
+	   # Source tree
+	   echo "$srcdir/$f"
+	 else
+	   # /dev/null tree
+	   { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+   { (exit 1); exit 1; }; }
+	 fi;;
+      esac
+    done` || { (exit 1); exit 1; }
+  # Remove the trailing spaces.
+  sed 's/[	 ]*$//' $ac_file_inputs >$tmp/in
+
+_ACEOF
+
+# Transform confdefs.h into two sed scripts, `conftest.defines' and
+# `conftest.undefs', that substitutes the proper values into
+# config.h.in to produce config.h.  The first handles `#define'
+# templates, and the second `#undef' templates.
+# And first: Protect against being on the right side of a sed subst in
+# config.status.  Protect against being in an unquoted here document
+# in config.status.
+rm -f conftest.defines conftest.undefs
+# Using a here document instead of a string reduces the quoting nightmare.
+# Putting comments in sed scripts is not portable.
+#
+# `end' is used to avoid that the second main sed command (meant for
+# 0-ary CPP macros) applies to n-ary macro definitions.
+# See the Autoconf documentation for `clear'.
+cat >confdef2sed.sed <<\_ACEOF
+s/[\\&,]/\\&/g
+s,[\\$`],\\&,g
+t clear
+: clear
+s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*\)\(([^)]*)\)[	 ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
+t end
+s,^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
+: end
+_ACEOF
+# If some macros were called several times there might be several times
+# the same #defines, which is useless.  Nevertheless, we may not want to
+# sort them, since we want the *last* AC-DEFINE to be honored.
+uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
+sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
+rm -f confdef2sed.sed
+
+# This sed command replaces #undef with comments.  This is necessary, for
+# example, in the case of _POSIX_SOURCE, which is predefined and required
+# on some systems where configure will not decide to define it.
+cat >>conftest.undefs <<\_ACEOF
+s,^[	 ]*#[	 ]*undef[	 ][	 ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
+_ACEOF
+
+# Break up conftest.defines because some shells have a limit on the size
+# of here documents, and old seds have small limits too (100 cmds).
+echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
+echo '  if grep "^[	 ]*#[	 ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
+echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
+echo '  :' >>$CONFIG_STATUS
+rm -f conftest.tail
+while grep . conftest.defines >/dev/null
+do
+  # Write a limited-size here document to $tmp/defines.sed.
+  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
+  # Speed up: don't consider the non `#define' lines.
+  echo '/^[	 ]*#[	 ]*define/!b' >>$CONFIG_STATUS
+  # Work around the forget-to-reset-the-flag bug.
+  echo 't clr' >>$CONFIG_STATUS
+  echo ': clr' >>$CONFIG_STATUS
+  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
+  echo 'CEOF
+  sed -f $tmp/defines.sed $tmp/in >$tmp/out
+  rm -f $tmp/in
+  mv $tmp/out $tmp/in
+' >>$CONFIG_STATUS
+  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
+  rm -f conftest.defines
+  mv conftest.tail conftest.defines
+done
+rm -f conftest.defines
+echo '  fi # grep' >>$CONFIG_STATUS
+echo >>$CONFIG_STATUS
+
+# Break up conftest.undefs because some shells have a limit on the size
+# of here documents, and old seds have small limits too (100 cmds).
+echo '  # Handle all the #undef templates' >>$CONFIG_STATUS
+rm -f conftest.tail
+while grep . conftest.undefs >/dev/null
+do
+  # Write a limited-size here document to $tmp/undefs.sed.
+  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
+  # Speed up: don't consider the non `#undef'
+  echo '/^[	 ]*#[	 ]*undef/!b' >>$CONFIG_STATUS
+  # Work around the forget-to-reset-the-flag bug.
+  echo 't clr' >>$CONFIG_STATUS
+  echo ': clr' >>$CONFIG_STATUS
+  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
+  echo 'CEOF
+  sed -f $tmp/undefs.sed $tmp/in >$tmp/out
+  rm -f $tmp/in
+  mv $tmp/out $tmp/in
+' >>$CONFIG_STATUS
+  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
+  rm -f conftest.undefs
+  mv conftest.tail conftest.undefs
+done
+rm -f conftest.undefs
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+  # Let's still pretend it is `configure' which instantiates (i.e., don't
+  # use $as_me), people would be surprised to read:
+  #    /* config.h.  Generated by config.status.  */
+  if test x"$ac_file" = x-; then
+    echo "/* Generated by configure.  */" >$tmp/config.h
+  else
+    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h
+  fi
+  cat $tmp/in >>$tmp/config.h
+  rm -f $tmp/in
+  if test x"$ac_file" != x-; then
+    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
+      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+      { if $as_mkdir_p; then
+    mkdir -p "$ac_dir"
+  else
+    as_dir="$ac_dir"
+    as_dirs=
+    while test ! -d "$as_dir"; do
+      as_dirs="$as_dir $as_dirs"
+      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+    done
+    test ! -n "$as_dirs" || mkdir $as_dirs
+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+   { (exit 1); exit 1; }; }; }
+
+      rm -f $ac_file
+      mv $tmp/config.h $ac_file
+    fi
+  else
+    cat $tmp/config.h
+    rm -f $tmp/config.h
+  fi
+# Compute $ac_file's index in $config_headers.
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $ac_file | $ac_file:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||
+$as_expr X$ac_file : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X$ac_file : 'X\(//\)[^/]' \| \
+	 X$ac_file : 'X\(//\)$' \| \
+	 X$ac_file : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X$ac_file |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`/stamp-h$_am_stamp_count
+done
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+#
+# CONFIG_COMMANDS section.
+#
+for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue
+  ac_dest=`echo "$ac_file" | sed 's,:.*,,'`
+  ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`
+  ac_dir=`(dirname "$ac_dest") 2>/dev/null ||
+$as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_dest" : 'X\(//\)[^/]' \| \
+	 X"$ac_dest" : 'X\(//\)$' \| \
+	 X"$ac_dest" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$ac_dest" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+  { if $as_mkdir_p; then
+    mkdir -p "$ac_dir"
+  else
+    as_dir="$ac_dir"
+    as_dirs=
+    while test ! -d "$as_dir"; do
+      as_dirs="$as_dir $as_dirs"
+      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+    done
+    test ! -n "$as_dirs" || mkdir $as_dirs
+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+   { (exit 1); exit 1; }; }; }
+
+  ac_builddir=.
+
+if test "$ac_dir" != .; then
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A "../" for each directory in $ac_dir_suffix.
+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+  ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+  .)  # No --srcdir option.  We are building in place.
+    ac_srcdir=.
+    if test -z "$ac_top_builddir"; then
+       ac_top_srcdir=.
+    else
+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+    fi ;;
+  [\\/]* | ?:[\\/]* )  # Absolute path.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir ;;
+  *) # Relative path.
+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+
+# Do not use `cd foo && pwd` to compute absolute paths, because
+# the directories may not exist.
+case `pwd` in
+.) ac_abs_builddir="$ac_dir";;
+*)
+  case "$ac_dir" in
+  .) ac_abs_builddir=`pwd`;;
+  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
+  *) ac_abs_builddir=`pwd`/"$ac_dir";;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_builddir=${ac_top_builddir}.;;
+*)
+  case ${ac_top_builddir}. in
+  .) ac_abs_top_builddir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
+  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_srcdir=$ac_srcdir;;
+*)
+  case $ac_srcdir in
+  .) ac_abs_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
+  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
+  esac;;
+esac
+case $ac_abs_builddir in
+.) ac_abs_top_srcdir=$ac_top_srcdir;;
+*)
+  case $ac_top_srcdir in
+  .) ac_abs_top_srcdir=$ac_abs_builddir;;
+  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
+  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
+  esac;;
+esac
+
+
+  { echo "$as_me:$LINENO: executing $ac_dest commands" >&5
+echo "$as_me: executing $ac_dest commands" >&6;}
+  case $ac_dest in
+    default-1 )
+# Only add multilib support code if we just rebuilt the top-level
+# Makefile.
+case " $CONFIG_FILES " in
+ *" Makefile "*)
+   ac_file=Makefile . ${multi_basedir}/config-ml.in
+   ;;
+esac ;;
+    depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do
+  # Strip MF so we end up with the name of the file.
+  mf=`echo "$mf" | sed -e 's/:.*$//'`
+  # Check whether this is an Automake generated Makefile or not.
+  # We used to match only the files named `Makefile.in', but
+  # some people rename them; so instead we look at the file content.
+  # Grep'ing the first line is not enough: some people post-process
+  # each Makefile.in and add a new line on top of each file to say so.
+  # So let's grep whole file.
+  if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+    dirpart=`(dirname "$mf") 2>/dev/null ||
+$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$mf" : 'X\(//\)[^/]' \| \
+	 X"$mf" : 'X\(//\)$' \| \
+	 X"$mf" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$mf" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+  else
+    continue
+  fi
+  # Extract the definition of DEPDIR, am__include, and am__quote
+  # from the Makefile without running `make'.
+  DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+  test -z "$DEPDIR" && continue
+  am__include=`sed -n 's/^am__include = //p' < "$mf"`
+  test -z "am__include" && continue
+  am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+  # When using ansi2knr, U may be empty or an underscore; expand it
+  U=`sed -n 's/^U = //p' < "$mf"`
+  # Find all dependency output files, they are included files with
+  # $(DEPDIR) in their names.  We invoke sed twice because it is the
+  # simplest approach to changing $(DEPDIR) to its actual value in the
+  # expansion.
+  for file in `sed -n "
+    s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+       sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
+    # Make sure the directory exists.
+    test -f "$dirpart/$file" && continue
+    fdir=`(dirname "$file") 2>/dev/null ||
+$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$file" : 'X\(//\)[^/]' \| \
+	 X"$file" : 'X\(//\)$' \| \
+	 X"$file" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+    { if $as_mkdir_p; then
+    mkdir -p $dirpart/$fdir
+  else
+    as_dir=$dirpart/$fdir
+    as_dirs=
+    while test ! -d "$as_dir"; do
+      as_dirs="$as_dir $as_dirs"
+      as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| \
+	 .     : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+  	  /^X\(\/\/\)$/{ s//\1/; q; }
+  	  /^X\(\/\).*/{ s//\1/; q; }
+  	  s/.*/./; q'`
+    done
+    test ! -n "$as_dirs" || mkdir $as_dirs
+  fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5
+echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}
+   { (exit 1); exit 1; }; }; }
+
+    # echo "creating $dirpart/$file"
+    echo '# dummy' > "$dirpart/$file"
+  done
+done
+ ;;
+  esac
+done
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+{ (exit 0); exit 0; }
+_ACEOF
+chmod +x $CONFIG_STATUS
+ac_clean_files=$ac_clean_files_save
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || { (exit 1); exit 1; }
+fi
+

Propchange: llvm-gcc-4.2/trunk/libmudflap/configure

------------------------------------------------------------------------------
    svn:executable = *

Added: llvm-gcc-4.2/trunk/libmudflap/configure.ac
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/configure.ac?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/configure.ac (added)
+++ llvm-gcc-4.2/trunk/libmudflap/configure.ac Thu Nov  8 16:56:19 2007
@@ -0,0 +1,269 @@
+# Process this file with autoconf to produce a configure script, like so:
+# aclocal -I .. -I ../config && autoconf && autoheader && automake
+
+AC_PREREQ(2.59)
+AC_INIT(libmudflap, 1.0)
+AC_CONFIG_SRCDIR(mf-runtime.c)
+AC_CANONICAL_SYSTEM
+ACX_NONCANONICAL_TARGET
+
+AM_INIT_AUTOMAKE
+
+AC_MSG_CHECKING([for --enable-version-specific-runtime-libs])
+AC_ARG_ENABLE(version-specific-runtime-libs,
+[  --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory ],
+[case "$enableval" in
+ yes) version_specific_libs=yes ;;
+ no)  version_specific_libs=no ;;
+ *)   AC_MSG_ERROR([Unknown argument to enable/disable version-specific libs]);;
+ esac],
+[version_specific_libs=no])
+AC_MSG_RESULT($version_specific_libs)
+
+AM_MAINTAINER_MODE
+AC_EXEEXT
+
+AM_ENABLE_MULTILIB(, ..)
+
+target_alias=${target_alias-$host_alias}
+AC_SUBST(target_alias)
+
+AC_CONFIG_HEADERS(config.h)
+
+AC_LANG_C
+# The same as in boehm-gc and libstdc++. Have to borrow it from there.
+# We must force CC to /not/ be precious variables; otherwise
+# the wrong, non-multilib-adjusted value will be used in multilibs.
+# As a side effect, we have to subst CFLAGS ourselves.
+
+m4_rename([_AC_ARG_VAR_PRECIOUS],[real_PRECIOUS])
+m4_define([_AC_ARG_VAR_PRECIOUS],[])
+AC_PROG_CC
+m4_rename([real_PRECIOUS],[_AC_ARG_VAR_PRECIOUS])
+
+AC_SUBST(CFLAGS)
+
+if test "x$GCC" != "xyes"; then
+  AC_MSG_ERROR([libmudflap must be built with GCC])
+fi
+AC_PROG_CPP
+
+# Some hosts don't have dlsym(RTLD_NEXT, "symbol") for use in
+# symbol interposition.  We disable shared libraries for these.
+AC_MSG_CHECKING([whether dlsym(RTLD_NEXT,...) is available])
+AC_TRY_COMPILE([
+#define _GNU_SOURCE
+#include <dlfcn.h>
+],
+[void *foo = dlsym (RTLD_NEXT, "exit");],
+[AC_MSG_RESULT(yes)],
+[AC_MSG_RESULT(no)
+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/mman.h)
+
+AC_CHECK_FUNCS(backtrace backtrace_symbols gettimeofday signal)
+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)
+AC_CHECK_FUNCS(getlogin_r getpwnam_r getpwuid_r getgrnam_r getgrgid_r)
+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 mmap munmap)
+
+AC_TRY_COMPILE([#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>],[union semun foo;], [mf_have_semun=1], [mf_have_semun=0])
+if test $mf_have_semun = 1
+then
+  AC_DEFINE(HAVE_UNION_SEMUN, 1, [union semun defined in sys/ipc.h or sys/sem.h])
+fi
+
+
+AC_MSG_CHECKING([for socklen_t in sys/socket.h])
+AC_TRY_COMPILE([#define _POSIX_PII_SOCKET
+#include <sys/types.h>
+#include <sys/socket.h>], [socklen_t x = 5;],
+  [AC_DEFINE(HAVE_SOCKLEN_T, 1, [Define it socklen_t typedef is in sys/socket.h.])
+   AC_MSG_RESULT(yes)],
+  [AC_MSG_RESULT(no)])
+
+AC_LIBTOOL_DLOPEN
+AM_PROG_LIBTOOL
+AC_SUBST(enable_shared)
+AC_SUBST(enable_static)
+
+AC_CHECK_HEADER(stdint.h, [MF_HAVE_STDINT_H=1], [MF_HAVE_STDINT_H=0])
+AC_SUBST(MF_HAVE_STDINT_H)
+if test $MF_HAVE_STDINT_H = 1
+then
+   MF_HAVE_UINTPTR_T=1
+else
+   AC_TRY_COMPILE([#include <sys/types.h>], [uintptr_t k = 0;],
+	[MF_HAVE_UINTPTR_T=1], [MF_HAVE_UINTPTR_T=0])
+fi
+AC_SUBST(MF_HAVE_UINTPTR_T)
+
+if test ! -d pth
+then
+  # libmudflapth objects are built in this subdirectory
+  mkdir pth
+fi
+
+AC_CHECK_HEADERS(pthread.h)
+
+AC_MSG_CHECKING([for thread model used by GCC])
+target_thread_file=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
+AC_MSG_RESULT([$target_thread_file])
+
+# We only support posix threads, or no threads at all.
+posix_threads=
+case ${target_thread_file} in
+  posix)
+    posix_threads=yes
+    ;;
+  single)
+    ;;
+  *)
+    echo "${target_thread_file} is an unsupported thread package" 1>&2
+    exit 1
+    ;;
+esac
+
+AM_CONDITIONAL(LIBMUDFLAPTH, [test "x$posix_threads" != "x"])
+if test "x$posix_threads" != "x"
+then
+        build_libmudflapth=1
+else
+        build_libmudflapth=0
+fi
+AC_SUBST(build_libmudflapth)
+
+AC_CHECK_LIB(dl, dlsym)
+
+# Calculate toolexeclibdir
+# Also toolexecdir, though it's only used in toolexeclibdir
+case ${version_specific_libs} in
+  yes)
+    # Need the gcc compiler version to know where to install libraries
+    # and header files if --enable-version-specific-runtime-libs option
+    # is selected.
+    toolexecdir='$(libdir)/gcc/$(target_alias)'
+    toolexeclibdir='$(toolexecdir)/$(gcc_version)$(MULTISUBDIR)'
+    ;;
+  no)
+    if test -n "$with_cross_host" &&
+       test x"$with_cross_host" != x"no"; then
+      # Install a library built with a cross compiler in tooldir, not libdir.
+      toolexecdir='$(exec_prefix)/$(target_alias)'
+      toolexeclibdir='$(toolexecdir)/lib'
+    else
+      toolexecdir='$(libdir)/gcc-lib/$(target_alias)'
+      toolexeclibdir='$(libdir)'
+    fi
+    multi_os_directory=`$CC -print-multi-os-directory`
+    case $multi_os_directory in
+      .) ;; # Avoid trailing /.
+      *) toolexeclibdir=$toolexeclibdir/$multi_os_directory ;;
+    esac
+    ;;
+esac
+AC_SUBST(toolexecdir)
+AC_SUBST(toolexeclibdir)
+
+includedir=${toolexecdir}/include
+AC_SUBST(includedir)
+
+pthread_create_version='""'
+if test "x$enable_shared" = "xyes" && test "x$posix_threads" != "x"; then
+  # NB: don't check for -lpthread here, because then it would be
+  # added to LIBS.  For the thread-unaware libmudflap.la, we don't
+  # want it there.
+
+  # glibc-related hacks.  dlsym() may pick the wrong version of
+  # interposed functions like pthread_create on modern glibc.
+  # We need to find the proper symbol version string, and use
+  # the nonstandard dlvsym().
+  AC_CHECK_FUNCS(dlvsym)
+  AC_CHECK_TOOL(NM, nm)
+  if test "x$ac_cv_have_dlvsym" != "x"; then
+    # Try compiling a simple pthreads program.  Find the shared libraries it
+    # ends up with.  Then use "nm" on those libraries to extract the
+    # default symbol versioning suffix ("@@"), if any.  But that's tricky.
+    # Rather, run nm on the resulting executable.  Unfortunately, autoconf
+    # doesn't appear to have a macro that builds a test executable for
+    # subsequent analysis ... so we do it by hand here.
+    cat >> conftest.c << EOF
+#include <pthread.h>
+int main () { void *p = (void *) & pthread_create; return (int) p; }
+EOF
+    oldLIBS="$LIBS"
+    LIBS="$LIBS -lpthread"
+    pthread_create_version="\"\""
+    AC_MSG_CHECKING(pthread_create symbol version)
+    if eval $ac_link 2>&5 && test -s conftest${ac_exeext}; then
+      version=`$NM conftest${ac_exeect} | grep 'pthread_create@@' | sed -e 's/^.*@@//'`
+      if test "x$version" != "x"; then
+        pthread_create_version="\"$version\""
+      fi
+    fi
+    AC_MSG_RESULT($pthread_create_version)
+    LIBS="$oldLIBS"
+  fi
+fi
+AC_DEFINE_UNQUOTED(PTHREAD_CREATE_VERSION, $pthread_create_version, [pthread_create symbol version])
+
+
+# Figure out whether the compiler supports "-ffunction-sections -fdata-sections",
+# similarly to how libstdc++ does it
+ac_test_CFLAGS="${CFLAGS+set}"
+ac_save_CFLAGS="$CFLAGS"
+
+# Check for -ffunction-sections -fdata-sections
+AC_MSG_CHECKING([for gcc that supports -ffunction-sections -fdata-sections])
+CFLAGS='-Werror -ffunction-sections -fdata-sections'
+AC_TRY_COMPILE(, [int foo;], [ac_fdsections=yes], [ac_fdsections=no])
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS="$ac_save_CFLAGS"
+else
+  # this is the suspicious part
+  CFLAGS=""
+fi
+if test x"$ac_fdsections" = x"yes"; then
+  SECTION_FLAGS='-ffunction-sections -fdata-sections'
+fi
+AC_MSG_RESULT($ac_fdsections)
+AC_SUBST(SECTION_FLAGS)
+
+
+# Check for the name of the symbol used for the entry point.
+AC_CACHE_CHECK([for the name of the symbol used for the entry point],
+  [mudflap_cv_entry_point], [
+for name in _start __start unknown; do
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([extern char $name@<:@@:>@;], [$name@<:@0@:>@ = 0;])],
+		 [break])
+done
+mudflap_cv_entry_point="$name"])
+if test "$mudflap_cv_entry_point" = unknown; then
+  AC_MSG_ERROR([none of the known symbol names works])
+fi
+AC_DEFINE_UNQUOTED([ENTRY_POINT], [$mudflap_cv_entry_point],
+  [Define to the name of the symbol used for the entry point.])
+
+
+if test ${multilib} = yes; then
+  multilib_arg="--enable-multilib"
+else
+  multilib_arg=
+fi
+
+# See if we support thread-local storage.
+GCC_CHECK_TLS
+
+AC_CONFIG_FILES([Makefile testsuite/Makefile testsuite/mfconfig.exp])
+AC_OUTPUT

Added: llvm-gcc-4.2/trunk/libmudflap/libtool-version
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/libtool-version?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/libtool-version (added)
+++ llvm-gcc-4.2/trunk/libmudflap/libtool-version Thu Nov  8 16:56:19 2007
@@ -0,0 +1,6 @@
+# This file is used to maintain libtool version info for libmudflap.  See
+# the libtool manual to understand the meaning of the fields.  This is
+# a separate file so that version updates don't involve re-running
+# automake.
+# CURRENT:REVISION:AGE
+0:0:0

Added: llvm-gcc-4.2/trunk/libmudflap/mf-heuristics.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/mf-heuristics.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/mf-heuristics.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/mf-heuristics.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,175 @@
+/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
+   Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+   Contributed by Frank Ch. Eigler <fche at redhat.com>
+   and Graydon Hoare <graydon at redhat.com>
+
+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 2, or (at your option) any later
+version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+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 COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+
+#include "config.h"
+
+#include <stdio.h>
+
+#include "mf-runtime.h"
+#include "mf-impl.h"
+
+#ifdef _MUDFLAP
+#error "Do not compile this file with -fmudflap!"
+#endif
+
+
+extern char _end[];
+extern char ENTRY_POINT[];
+
+
+/* Run some quick validation of the given region.
+   Return -1 / 0 / 1 if the access known-invalid, possibly-valid, or known-valid.
+*/
+int
+__mf_heuristic_check (uintptr_t ptr, uintptr_t ptr_high)
+{
+  VERBOSE_TRACE ("mf: heuristic check\n");
+
+  /* XXX: Disable the stack bounding check for libmudflapth.  We do
+     actually have enough information to track stack bounds (see
+     __mf_pthread_info in mf-hooks.c), so with a bit of future work,
+     this heuristic can be turned on.  */
+#ifndef LIBMUDFLAPTH
+
+  /* The first heuristic is to check stack bounds.  This is a
+     transient condition and quick to check. */
+  if (__mf_opts.heur_stack_bound)
+    {
+      uintptr_t stack_top_guess = (uintptr_t)__builtin_frame_address(0);
+#if defined(__i386__) && defined (__linux__)
+      uintptr_t stack_segment_base = 0xC0000000; /* XXX: Bad assumption. */
+#else
+      /* Cause tests to fail. */
+      uintptr_t stack_segment_base = 0;
+#endif
+
+      VERBOSE_TRACE ("mf: stack estimated as %p-%p\n",
+		     (void *) stack_top_guess, (void *) stack_segment_base);
+
+      if (ptr_high <= stack_segment_base &&
+	  ptr >= stack_top_guess &&
+	  ptr_high >= ptr)
+	{
+	  return 1;
+	}
+    }
+#endif
+
+
+  /* The second heuristic is to scan the range of memory regions
+     listed in /proc/self/maps, a special file provided by the Linux
+     kernel.  Its results may be cached, and in fact, a GUESS object
+     may as well be recorded for interesting matching sections.  */
+  if (__mf_opts.heur_proc_map)
+    {
+      /* Keep a record of seen records from /proc/self/map.  */
+      enum { max_entries = 500 };
+      struct proc_self_map_entry
+      {
+	uintptr_t low;
+	uintptr_t high;
+      };
+      static struct proc_self_map_entry entry [max_entries];
+      static unsigned entry_used [max_entries];
+
+      /* Look for a known proc_self_map entry that may cover this
+	 region.  If one exists, then this heuristic has already run,
+	 and should not be run again.  The check should be allowed to
+	 fail.  */
+      unsigned i;
+      unsigned deja_vu = 0;
+      for (i=0; i<max_entries; i++)
+	{
+	  if (entry_used[i] &&
+	      (entry[i].low <= ptr) &&
+	      (entry[i].high >= ptr_high))
+	    deja_vu = 1;
+	}
+
+      if (! deja_vu)
+	{
+	  /* Time to run the heuristic.  Rescan /proc/self/maps; update the
+	     entry[] array; XXX: remove expired entries, add new ones.
+	     XXX: Consider entries that have grown (e.g., stack).  */
+	  char buf[512];
+	  char flags[4];
+	  void *low, *high;
+	  FILE *fp;
+
+	  fp = fopen ("/proc/self/maps", "r");
+	  if (fp)
+	    {
+	      while (fgets (buf, sizeof(buf), fp))
+		{
+		  if (sscanf (buf, "%p-%p %4c", &low, &high, flags) == 3)
+		    {
+		      if ((uintptr_t) low <= ptr &&
+			  (uintptr_t) high >= ptr_high)
+			{
+			  for (i=0; i<max_entries; i++)
+			    {
+			      if (! entry_used[i])
+				{
+				  entry[i].low = (uintptr_t) low;
+				  entry[i].high = (uintptr_t) high;
+				  entry_used[i] = 1;
+				  break;
+				}
+			    }
+
+			  VERBOSE_TRACE ("mf: registering region #%d "
+					 "%p-%p given %s",
+					 i, (void *) low, (void *) high, buf);
+
+			  __mfu_register ((void *) low, (size_t) (high-low),
+					  __MF_TYPE_GUESS,
+					  "/proc/self/maps segment");
+
+			  return 0; /* undecided (tending to cachable) */
+			}
+		    }
+		}
+	      fclose (fp);
+	    }
+	}
+    }
+
+
+  /* The third heuristic is to approve all accesses between _start (or its
+     equivalent for the given target) and _end, which should include all
+     text and initialized data.  */
+  if (__mf_opts.heur_start_end)
+    if (ptr >= (uintptr_t) & ENTRY_POINT && ptr_high <= (uintptr_t) & _end)
+      return 1; /* uncacheable */
+
+  return 0; /* unknown */
+}

Added: llvm-gcc-4.2/trunk/libmudflap/mf-hooks1.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/mf-hooks1.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/mf-hooks1.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/mf-hooks1.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,485 @@
+/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
+   Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+   Contributed by Frank Ch. Eigler <fche at redhat.com>
+   and Graydon Hoare <graydon at redhat.com>
+
+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 2, or (at your option) any later
+version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+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 COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+
+#include "config.h"
+
+#ifndef HAVE_SOCKLEN_T
+#define socklen_t int
+#endif
+
+
+/* These attempt to coax various unix flavours to declare all our
+   needed tidbits in the system headers.  */
+#if !defined(__FreeBSD__)  && !defined(__APPLE__)
+#define _POSIX_SOURCE
+#endif /* Some BSDs break <sys/socket.h> if this is defined. */
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE
+#define _BSD_TYPES
+#define __EXTENSIONS__
+#define _ALL_SOURCE
+#define _LARGE_FILE_API
+#define _XOPEN_SOURCE_EXTENDED 1
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <time.h>
+
+#include "mf-runtime.h"
+#include "mf-impl.h"
+
+#ifdef _MUDFLAP
+#error "Do not compile this file with -fmudflap!"
+#endif
+
+
+/* Memory allocation related hook functions.  Some of these are
+   intercepted via linker wrapping or symbol interposition.  Others
+   use plain macros in mf-runtime.h.  */
+
+
+#if PIC
+/* A special bootstrap variant. */
+void *
+__mf_0fn_malloc (size_t c)
+{
+  enum foo { BS = 4096, NB=10 };
+  static char bufs[NB][BS];
+  static unsigned bufs_used[NB];
+  unsigned i;
+
+  for (i=0; i<NB; i++)
+    {
+      if (! bufs_used[i] && c < BS)
+	{
+	  bufs_used[i] = 1;
+	  return & bufs[i][0];
+	}
+    }
+  return NULL;
+}
+#endif
+
+
+#undef malloc
+WRAPPER(void *, malloc, size_t c)
+{
+  size_t size_with_crumple_zones;
+  DECLARE(void *, malloc, size_t c);
+  void *result;
+  BEGIN_PROTECT (malloc, c);
+
+  size_with_crumple_zones =
+    CLAMPADD(c,CLAMPADD(__mf_opts.crumple_zone,
+			__mf_opts.crumple_zone));
+  BEGIN_MALLOC_PROTECT ();
+  result = (char *) CALL_REAL (malloc, size_with_crumple_zones);
+  END_MALLOC_PROTECT ();
+
+  if (LIKELY(result))
+    {
+      result += __mf_opts.crumple_zone;
+      __mf_register (result, c, __MF_TYPE_HEAP, "malloc region");
+      /* XXX: register __MF_TYPE_NOACCESS for crumple zones.  */
+    }
+
+  return result;
+}
+
+
+#ifdef PIC
+/* A special bootstrap variant. */
+void *
+__mf_0fn_calloc (size_t c, size_t n)
+{
+  return __mf_0fn_malloc (c * n);
+}
+#endif
+
+
+#undef calloc
+WRAPPER(void *, calloc, size_t c, size_t n)
+{
+  size_t size_with_crumple_zones;
+  DECLARE(void *, calloc, size_t, size_t);
+  DECLARE(void *, malloc, size_t);
+  DECLARE(void *, memset, void *, int, size_t);
+  char *result;
+  BEGIN_PROTECT (calloc, c, n);
+
+  size_with_crumple_zones =
+    CLAMPADD((c * n), /* XXX: CLAMPMUL */
+	     CLAMPADD(__mf_opts.crumple_zone,
+		      __mf_opts.crumple_zone));
+  BEGIN_MALLOC_PROTECT ();
+  result = (char *) CALL_REAL (malloc, size_with_crumple_zones);
+  END_MALLOC_PROTECT ();
+
+  if (LIKELY(result))
+    memset (result, 0, size_with_crumple_zones);
+
+  if (LIKELY(result))
+    {
+      result += __mf_opts.crumple_zone;
+      __mf_register (result, c*n /* XXX: clamp */, __MF_TYPE_HEAP_I, "calloc region");
+      /* XXX: register __MF_TYPE_NOACCESS for crumple zones.  */
+    }
+
+  return result;
+}
+
+
+#if PIC
+/* A special bootstrap variant. */
+void *
+__mf_0fn_realloc (void *buf, size_t c)
+{
+  return NULL;
+}
+#endif
+
+
+#undef realloc
+WRAPPER(void *, realloc, void *buf, size_t c)
+{
+  DECLARE(void * , realloc, void *, size_t);
+  size_t size_with_crumple_zones;
+  char *base = buf;
+  unsigned saved_wipe_heap;
+  char *result;
+  BEGIN_PROTECT (realloc, buf, c);
+
+  if (LIKELY(buf))
+    base -= __mf_opts.crumple_zone;
+
+  size_with_crumple_zones =
+    CLAMPADD(c, CLAMPADD(__mf_opts.crumple_zone,
+			 __mf_opts.crumple_zone));
+  BEGIN_MALLOC_PROTECT ();
+  result = (char *) CALL_REAL (realloc, base, size_with_crumple_zones);
+  END_MALLOC_PROTECT ();
+
+  /* Ensure heap wiping doesn't occur during this peculiar
+     unregister/reregister pair.  */
+  LOCKTH ();
+  __mf_set_state (reentrant);
+  saved_wipe_heap = __mf_opts.wipe_heap;
+  __mf_opts.wipe_heap = 0;
+
+  if (LIKELY(buf))
+    __mfu_unregister (buf, 0, __MF_TYPE_HEAP_I);
+  /* NB: underlying region may have been __MF_TYPE_HEAP. */
+
+  if (LIKELY(result))
+    {
+      result += __mf_opts.crumple_zone;
+      __mfu_register (result, c, __MF_TYPE_HEAP_I, "realloc region");
+      /* XXX: register __MF_TYPE_NOACCESS for crumple zones.  */
+    }
+
+  /* Restore previous setting.  */
+  __mf_opts.wipe_heap = saved_wipe_heap;
+
+  __mf_set_state (active);
+  UNLOCKTH ();
+
+  return result;
+}
+
+
+#if PIC
+/* A special bootstrap variant. */
+void
+__mf_0fn_free (void *buf)
+{
+  return;
+}
+#endif
+
+#undef free
+WRAPPER(void, free, void *buf)
+{
+  /* Use a circular queue to delay some number (__mf_opts.free_queue_length) of free()s.  */
+  static void *free_queue [__MF_FREEQ_MAX];
+  static unsigned free_ptr = 0;
+  static int freeq_initialized = 0;
+  DECLARE(void, free, void *);
+
+  BEGIN_PROTECT (free, buf);
+
+  if (UNLIKELY(buf == NULL))
+    return;
+
+  LOCKTH ();
+  if (UNLIKELY(!freeq_initialized))
+    {
+      memset (free_queue, 0,
+		     __MF_FREEQ_MAX * sizeof (void *));
+      freeq_initialized = 1;
+    }
+  UNLOCKTH ();
+
+  __mf_unregister (buf, 0, __MF_TYPE_HEAP_I);
+  /* NB: underlying region may have been __MF_TYPE_HEAP. */
+
+  if (UNLIKELY(__mf_opts.free_queue_length > 0))
+    {
+      char *freeme = NULL;
+      LOCKTH ();
+      if (free_queue [free_ptr] != NULL)
+	{
+	  freeme = free_queue [free_ptr];
+	  freeme -= __mf_opts.crumple_zone;
+	}
+      free_queue [free_ptr] = buf;
+      free_ptr = (free_ptr == (__mf_opts.free_queue_length-1) ? 0 : free_ptr + 1);
+      UNLOCKTH ();
+      if (freeme)
+	{
+	  if (__mf_opts.trace_mf_calls)
+	    {
+	      VERBOSE_TRACE ("freeing deferred pointer %p (crumple %u)\n",
+			     (void *) freeme,
+			     __mf_opts.crumple_zone);
+	    }
+	  BEGIN_MALLOC_PROTECT ();
+	  CALL_REAL (free, freeme);
+	  END_MALLOC_PROTECT ();
+	}
+    }
+  else
+    {
+      /* back pointer up a bit to the beginning of crumple zone */
+      char *base = (char *)buf;
+      base -= __mf_opts.crumple_zone;
+      if (__mf_opts.trace_mf_calls)
+	{
+	  VERBOSE_TRACE ("freeing pointer %p = %p - %u\n",
+			 (void *) base,
+			 (void *) buf,
+			 __mf_opts.crumple_zone);
+	}
+      BEGIN_MALLOC_PROTECT ();
+      CALL_REAL (free, base);
+      END_MALLOC_PROTECT ();
+    }
+}
+
+
+/* We can only wrap mmap if the target supports it.  Likewise for munmap.
+   We assume we have both if we have mmap.  */
+#ifdef HAVE_MMAP
+
+#if PIC
+/* A special bootstrap variant. */
+void *
+__mf_0fn_mmap (void *start, size_t l, int prot, int f, int fd, off_t off)
+{
+  return (void *) -1;
+}
+#endif
+
+
+#undef mmap
+WRAPPER(void *, mmap,
+	void  *start,  size_t length, int prot,
+	int flags, int fd, off_t offset)
+{
+  DECLARE(void *, mmap, void *, size_t, int,
+			    int, int, off_t);
+  void *result;
+  BEGIN_PROTECT (mmap, start, length, prot, flags, fd, offset);
+
+  result = CALL_REAL (mmap, start, length, prot,
+			flags, fd, offset);
+
+  /*
+  VERBOSE_TRACE ("mmap (%08lx, %08lx, ...) => %08lx\n",
+		 (uintptr_t) start, (uintptr_t) length,
+		 (uintptr_t) result);
+  */
+
+  if (result != (void *)-1)
+    {
+      /* Register each page as a heap object.  Why not register it all
+	 as a single segment?  That's so that a later munmap() call
+	 can unmap individual pages.  XXX: would __MF_TYPE_GUESS make
+	 this more automatic?  */
+      size_t ps = getpagesize ();
+      uintptr_t base = (uintptr_t) result;
+      uintptr_t offset;
+
+      for (offset=0; offset<length; offset+=ps)
+	{
+	  /* XXX: We could map PROT_NONE to __MF_TYPE_NOACCESS. */
+	  /* XXX: Unaccessed HEAP pages are reported as leaks.  Is this
+	     appropriate for unaccessed mmap pages? */
+	  __mf_register ((void *) CLAMPADD (base, offset), ps,
+			 __MF_TYPE_HEAP_I, "mmap page");
+	}
+    }
+
+  return result;
+}
+
+
+#if PIC
+/* A special bootstrap variant. */
+int
+__mf_0fn_munmap (void *start, size_t length)
+{
+  return -1;
+}
+#endif
+
+
+#undef munmap
+WRAPPER(int , munmap, void *start, size_t length)
+{
+  DECLARE(int, munmap, void *, size_t);
+  int result;
+  BEGIN_PROTECT (munmap, start, length);
+
+  result = CALL_REAL (munmap, start, length);
+
+  /*
+  VERBOSE_TRACE ("munmap (%08lx, %08lx, ...) => %08lx\n",
+		 (uintptr_t) start, (uintptr_t) length,
+		 (uintptr_t) result);
+  */
+
+  if (result == 0)
+    {
+      /* Unregister each page as a heap object.  */
+      size_t ps = getpagesize ();
+      uintptr_t base = (uintptr_t) start & (~ (ps - 1)); /* page align */
+      uintptr_t offset;
+
+      for (offset=0; offset<length; offset+=ps)
+	__mf_unregister ((void *) CLAMPADD (base, offset), ps, __MF_TYPE_HEAP_I);
+    }
+  return result;
+}
+#endif /* HAVE_MMAP */
+
+
+/* This wrapper is a little different, as it's called indirectly from
+   __mf_fini also to clean up pending allocations.  */
+void *
+__mf_wrap_alloca_indirect (size_t c)
+{
+  DECLARE (void *, malloc, size_t);
+  DECLARE (void, free, void *);
+
+  /* This struct, a linked list, tracks alloca'd objects.  The newest
+     object is at the head of the list.  If we detect that we've
+     popped a few levels of stack, then the listed objects are freed
+     as needed.  NB: The tracking struct is allocated with
+     real_malloc; the user data with wrap_malloc.
+  */
+  struct alloca_tracking { void *ptr; void *stack; struct alloca_tracking* next; };
+  static struct alloca_tracking *alloca_history = NULL;
+
+  void *stack = __builtin_frame_address (0);
+  void *result;
+  struct alloca_tracking *track;
+
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  VERBOSE_TRACE ("alloca stack level %p\n", (void *) stack);
+
+  /* XXX: thread locking! */
+
+  /* Free any previously alloca'd blocks that belong to deeper-nested functions,
+     which must therefore have exited by now.  */
+
+#define DEEPER_THAN < /* XXX: for x86; steal find_stack_direction() from libiberty/alloca.c */
+
+  while (alloca_history &&
+	 ((uintptr_t) alloca_history->stack DEEPER_THAN (uintptr_t) stack))
+    {
+      struct alloca_tracking *next = alloca_history->next;
+      __mf_unregister (alloca_history->ptr, 0, __MF_TYPE_HEAP);
+      BEGIN_MALLOC_PROTECT ();
+      CALL_REAL (free, alloca_history->ptr);
+      CALL_REAL (free, alloca_history);
+      END_MALLOC_PROTECT ();
+      alloca_history = next;
+    }
+
+  /* Allocate new block.  */
+  result = NULL;
+  if (LIKELY (c > 0)) /* alloca(0) causes no allocation.  */
+    {
+      BEGIN_MALLOC_PROTECT ();
+      track = (struct alloca_tracking *) CALL_REAL (malloc,
+						    sizeof (struct alloca_tracking));
+      END_MALLOC_PROTECT ();
+      if (LIKELY (track != NULL))
+	{
+	  BEGIN_MALLOC_PROTECT ();
+	  result = CALL_REAL (malloc, c);
+	  END_MALLOC_PROTECT ();
+	  if (UNLIKELY (result == NULL))
+	    {
+	      BEGIN_MALLOC_PROTECT ();
+	      CALL_REAL (free, track);
+	      END_MALLOC_PROTECT ();
+	      /* Too bad.  XXX: What about errno?  */
+	    }
+	  else
+	    {
+	      __mf_register (result, c, __MF_TYPE_HEAP, "alloca region");
+	      track->ptr = result;
+	      track->stack = stack;
+	      track->next = alloca_history;
+	      alloca_history = track;
+	    }
+	}
+    }
+
+  return result;
+}
+
+
+#undef alloca
+WRAPPER(void *, alloca, size_t c)
+{
+  return __mf_wrap_alloca_indirect (c);
+}
+

Added: llvm-gcc-4.2/trunk/libmudflap/mf-hooks2.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/mf-hooks2.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/mf-hooks2.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/mf-hooks2.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,2162 @@
+/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
+   Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+   Contributed by Frank Ch. Eigler <fche at redhat.com>
+   and Graydon Hoare <graydon at redhat.com>
+
+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 2, or (at your option) any later
+version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+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 COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+
+#include "config.h"
+
+#ifndef HAVE_SOCKLEN_T
+#define socklen_t int
+#endif
+
+/* These attempt to coax various unix flavours to declare all our
+   needed tidbits in the system headers.  */
+#if !defined(__FreeBSD__) && !defined(__APPLE__)
+#define _POSIX_SOURCE
+#endif /* Some BSDs break <sys/socket.h> if this is defined. */
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE
+#define _BSD_TYPES
+#define __EXTENSIONS__
+#define _ALL_SOURCE
+#define _LARGE_FILE_API
+#define _LARGEFILE64_SOURCE
+#define _XOPEN_SOURCE_EXTENDED 1
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <time.h>
+#include <ctype.h>
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+#ifdef HAVE_DIRENT_H
+#include <dirent.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+#ifdef HAVE_SYS_IPC_H
+#include <sys/ipc.h>
+#endif
+#ifdef HAVE_SYS_SEM_H
+#include <sys/sem.h>
+#endif
+#ifdef HAVE_SYS_SHM_H
+#include <sys/shm.h>
+#endif
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+#ifdef HAVE_GRP_H
+#include <grp.h>
+#endif
+#ifdef HAVE_MNTENT_H
+#include <mntent.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+
+#include "mf-runtime.h"
+#include "mf-impl.h"
+
+#ifdef _MUDFLAP
+#error "Do not compile this file with -fmudflap!"
+#endif
+
+
+/* A bunch of independent stdlib/unistd hook functions, all
+   intercepted by mf-runtime.h macros.  */
+
+#ifndef HAVE_STRNLEN
+static inline size_t (strnlen) (const char* str, size_t n)
+{
+  const char *s;
+
+  for (s = str; n && *s; ++s, --n)
+    ;
+  return (s - str);
+}
+#endif
+
+
+/* str*,mem*,b* */
+
+WRAPPER2(void *, memcpy, void *dest, const void *src, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memcpy source");
+  MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memcpy dest");
+  return memcpy (dest, src, n);
+}
+
+
+WRAPPER2(void *, memmove, void *dest, const void *src, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "memmove src");
+  MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "memmove dest");
+  return memmove (dest, src, n);
+}
+
+
+WRAPPER2(void *, memset, void *s, int c, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "memset dest");
+  return memset (s, c, n);
+}
+
+
+WRAPPER2(int, memcmp, const void *s1, const void *s2, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "memcmp 1st arg");
+  MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "memcmp 2nd arg");
+  return memcmp (s1, s2, n);
+}
+
+
+WRAPPER2(void *, memchr, const void *s, int c, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memchr region");
+  return memchr (s, c, n);
+}
+
+
+#ifdef HAVE_MEMRCHR
+WRAPPER2(void *, memrchr, const void *s, int c, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, n, __MF_CHECK_READ, "memrchr region");
+  return memrchr (s, c, n);
+}
+#endif
+
+
+WRAPPER2(char *, strcpy, char *dest, const char *src)
+{
+  /* nb: just because strlen(src) == n doesn't mean (src + n) or (src + n +
+     1) are valid pointers. the allocated object might have size < n.
+     check anyways. */
+
+  size_t n = strlen (src);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(src, CLAMPADD(n, 1), __MF_CHECK_READ, "strcpy src");
+  MF_VALIDATE_EXTENT(dest, CLAMPADD(n, 1), __MF_CHECK_WRITE, "strcpy dest");
+  return strcpy (dest, src);
+}
+
+
+#ifdef HAVE_STRNCPY
+WRAPPER2(char *, strncpy, char *dest, const char *src, size_t n)
+{
+  size_t len = strnlen (src, n);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(src, len, __MF_CHECK_READ, "strncpy src");
+  MF_VALIDATE_EXTENT(dest, len, __MF_CHECK_WRITE, "strncpy dest"); /* nb: strNcpy */
+  return strncpy (dest, src, n);
+}
+#endif
+
+
+WRAPPER2(char *, strcat, char *dest, const char *src)
+{
+  size_t dest_sz;
+  size_t src_sz;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  dest_sz = strlen (dest);
+  src_sz = strlen (src);
+  MF_VALIDATE_EXTENT(src, CLAMPADD(src_sz, 1), __MF_CHECK_READ, "strcat src");
+  MF_VALIDATE_EXTENT(dest, CLAMPADD(dest_sz, CLAMPADD(src_sz, 1)),
+		     __MF_CHECK_WRITE, "strcat dest");
+  return strcat (dest, src);
+}
+
+
+WRAPPER2(char *, strncat, char *dest, const char *src, size_t n)
+{
+
+  /* nb: validating the extents (s,n) might be a mistake for two reasons.
+
+  (1) the string s might be shorter than n chars, and n is just a
+  poor choice by the programmer. this is not a "true" error in the
+  sense that the call to strncat would still be ok.
+
+  (2) we could try to compensate for case (1) by calling strlen(s) and
+  using that as a bound for the extent to verify, but strlen might fall off
+  the end of a non-terminated string, leading to a false positive.
+
+  so we will call strnlen(s,n) and use that as a bound.
+
+  if strnlen returns a length beyond the end of the registered extent
+  associated with s, there is an error: the programmer's estimate for n is
+  too large _AND_ the string s is unterminated, in which case they'd be
+  about to touch memory they don't own while calling strncat.
+
+  this same logic applies to further uses of strnlen later down in this
+  file. */
+
+  size_t src_sz;
+  size_t dest_sz;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  src_sz = strnlen (src, n);
+  dest_sz = strnlen (dest, n);
+  MF_VALIDATE_EXTENT(src, src_sz, __MF_CHECK_READ, "strncat src");
+  MF_VALIDATE_EXTENT(dest, (CLAMPADD(dest_sz, CLAMPADD(src_sz, 1))),
+		     __MF_CHECK_WRITE, "strncat dest");
+  return strncat (dest, src, n);
+}
+
+
+WRAPPER2(int, strcmp, const char *s1, const char *s2)
+{
+  size_t s1_sz;
+  size_t s2_sz;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  s1_sz = strlen (s1);
+  s2_sz = strlen (s2);
+  MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcmp 1st arg");
+  MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_WRITE, "strcmp 2nd arg");
+  return strcmp (s1, s2);
+}
+
+
+WRAPPER2(int, strcasecmp, const char *s1, const char *s2)
+{
+  size_t s1_sz;
+  size_t s2_sz;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  s1_sz = strlen (s1);
+  s2_sz = strlen (s2);
+  MF_VALIDATE_EXTENT(s1, CLAMPADD(s1_sz, 1), __MF_CHECK_READ, "strcasecmp 1st arg");
+  MF_VALIDATE_EXTENT(s2, CLAMPADD(s2_sz, 1), __MF_CHECK_READ, "strcasecmp 2nd arg");
+  return strcasecmp (s1, s2);
+}
+
+
+WRAPPER2(int, strncmp, const char *s1, const char *s2, size_t n)
+{
+  size_t s1_sz;
+  size_t s2_sz;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  s1_sz = strnlen (s1, n);
+  s2_sz = strnlen (s2, n);
+  MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncmp 1st arg");
+  MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncmp 2nd arg");
+  return strncmp (s1, s2, n);
+}
+
+
+WRAPPER2(int, strncasecmp, const char *s1, const char *s2, size_t n)
+{
+  size_t s1_sz;
+  size_t s2_sz;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  s1_sz = strnlen (s1, n);
+  s2_sz = strnlen (s2, n);
+  MF_VALIDATE_EXTENT(s1, s1_sz, __MF_CHECK_READ, "strncasecmp 1st arg");
+  MF_VALIDATE_EXTENT(s2, s2_sz, __MF_CHECK_READ, "strncasecmp 2nd arg");
+  return strncasecmp (s1, s2, n);
+}
+
+
+WRAPPER2(char *, strdup, const char *s)
+{
+  DECLARE(void *, malloc, size_t sz);
+  char *result;
+  size_t n = strlen (s);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strdup region");
+  result = (char *)CALL_REAL(malloc,
+			     CLAMPADD(CLAMPADD(n,1),
+				      CLAMPADD(__mf_opts.crumple_zone,
+					       __mf_opts.crumple_zone)));
+
+  if (UNLIKELY(! result)) return result;
+
+  result += __mf_opts.crumple_zone;
+  memcpy (result, s, n);
+  result[n] = '\0';
+
+  __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strdup region");
+  return result;
+}
+
+
+WRAPPER2(char *, strndup, const char *s, size_t n)
+{
+  DECLARE(void *, malloc, size_t sz);
+  char *result;
+  size_t sz = strnlen (s, n);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, sz, __MF_CHECK_READ, "strndup region"); /* nb: strNdup */
+
+  /* note: strndup still adds a \0, even with the N limit! */
+  result = (char *)CALL_REAL(malloc,
+			     CLAMPADD(CLAMPADD(n,1),
+				      CLAMPADD(__mf_opts.crumple_zone,
+					       __mf_opts.crumple_zone)));
+
+  if (UNLIKELY(! result)) return result;
+
+  result += __mf_opts.crumple_zone;
+  memcpy (result, s, n);
+  result[n] = '\0';
+
+  __mf_register (result, CLAMPADD(n,1), __MF_TYPE_HEAP_I, "strndup region");
+  return result;
+}
+
+
+WRAPPER2(char *, strchr, const char *s, int c)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (s);
+  MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strchr region");
+  return strchr (s, c);
+}
+
+
+WRAPPER2(char *, strrchr, const char *s, int c)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (s);
+  MF_VALIDATE_EXTENT(s, CLAMPADD(n,1), __MF_CHECK_READ, "strrchr region");
+  return strrchr (s, c);
+}
+
+
+WRAPPER2(char *, strstr, const char *haystack, const char *needle)
+{
+  size_t haystack_sz;
+  size_t needle_sz;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  haystack_sz = strlen (haystack);
+  needle_sz = strlen (needle);
+  MF_VALIDATE_EXTENT(haystack, CLAMPADD(haystack_sz, 1), __MF_CHECK_READ, "strstr haystack");
+  MF_VALIDATE_EXTENT(needle, CLAMPADD(needle_sz, 1), __MF_CHECK_READ, "strstr needle");
+  return strstr (haystack, needle);
+}
+
+
+#ifdef HAVE_MEMMEM
+WRAPPER2(void *, memmem,
+	const void *haystack, size_t haystacklen,
+	const void *needle, size_t needlelen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(haystack, haystacklen, __MF_CHECK_READ, "memmem haystack");
+  MF_VALIDATE_EXTENT(needle, needlelen, __MF_CHECK_READ, "memmem needle");
+  return memmem (haystack, haystacklen, needle, needlelen);
+}
+#endif
+
+
+WRAPPER2(size_t, strlen, const char *s)
+{
+  size_t result = strlen (s);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, CLAMPADD(result, 1), __MF_CHECK_READ, "strlen region");
+  return result;
+}
+
+
+WRAPPER2(size_t, strnlen, const char *s, size_t n)
+{
+  size_t result = strnlen (s, n);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, result, __MF_CHECK_READ, "strnlen region");
+  return result;
+}
+
+
+WRAPPER2(void, bzero, void *s, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, n, __MF_CHECK_WRITE, "bzero region");
+  bzero (s, n);
+}
+
+
+#undef bcopy
+WRAPPER2(void, bcopy, const void *src, void *dest, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(src, n, __MF_CHECK_READ, "bcopy src");
+  MF_VALIDATE_EXTENT(dest, n, __MF_CHECK_WRITE, "bcopy dest");
+  bcopy (src, dest, n);
+}
+
+
+#undef bcmp
+WRAPPER2(int, bcmp, const void *s1, const void *s2, size_t n)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s1, n, __MF_CHECK_READ, "bcmp 1st arg");
+  MF_VALIDATE_EXTENT(s2, n, __MF_CHECK_READ, "bcmp 2nd arg");
+  return bcmp (s1, s2, n);
+}
+
+
+WRAPPER2(char *, index, const char *s, int c)
+{
+  size_t n = strlen (s);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "index region");
+  return index (s, c);
+}
+
+
+WRAPPER2(char *, rindex, const char *s, int c)
+{
+  size_t n = strlen (s);
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(s, CLAMPADD(n, 1), __MF_CHECK_READ, "rindex region");
+  return rindex (s, c);
+}
+
+/* XXX:  stpcpy, memccpy */
+
+/* XXX: *printf,*scanf */
+
+/* XXX: setjmp, longjmp */
+
+WRAPPER2(char *, asctime, struct tm *tm)
+{
+  static char *reg_result = NULL;
+  char *result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(tm, sizeof (struct tm), __MF_CHECK_READ, "asctime tm");
+  result = asctime (tm);
+  if (reg_result == NULL)
+    {
+      __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "asctime string");
+      reg_result = result;
+    }
+  return result;
+}
+
+
+WRAPPER2(char *, ctime, const time_t *timep)
+{
+  static char *reg_result = NULL;
+  char *result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "ctime time");
+  result = ctime (timep);
+  if (reg_result == NULL)
+    {
+      /* XXX: what if asctime and ctime return the same static ptr? */
+      __mf_register (result, strlen (result)+1, __MF_TYPE_STATIC, "ctime string");
+      reg_result = result;
+    }
+  return result;
+}
+
+
+WRAPPER2(struct tm*, localtime, const time_t *timep)
+{
+  static struct tm *reg_result = NULL;
+  struct tm *result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "localtime time");
+  result = localtime (timep);
+  if (reg_result == NULL)
+    {
+      __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "localtime tm");
+      reg_result = result;
+    }
+  return result;
+}
+
+
+WRAPPER2(struct tm*, gmtime, const time_t *timep)
+{
+  static struct tm *reg_result = NULL;
+  struct tm *result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT(timep, sizeof (time_t), __MF_CHECK_READ, "gmtime time");
+  result = gmtime (timep);
+  if (reg_result == NULL)
+    {
+      __mf_register (result, sizeof (struct tm), __MF_TYPE_STATIC, "gmtime tm");
+      reg_result = result;
+    }
+  return result;
+}
+
+
+/* EL start */
+
+/* The following indicate if the result of the corresponding function
+ * should be explicitly un/registered by the wrapper
+*/
+
+#ifdef __FreeBSD__
+#define MF_REGISTER_fopen		__MF_TYPE_STATIC
+#else
+#undef  MF_REGISTER_fopen
+#endif
+#define MF_RESULT_SIZE_fopen		(sizeof (FILE))
+
+#undef  MF_REGISTER_opendir
+#define MF_RESULT_SIZE_opendir		0	/* (sizeof (DIR)) */
+#undef  MF_REGISTER_readdir
+#define MF_REGISTER_gethostbyname	__MF_TYPE_STATIC
+#undef  MF_REGISTER_gethostbyname_items
+#undef  MF_REGISTER_dlopen
+#undef  MF_REGISTER_dlerror
+#undef  MF_REGISTER_dlsym
+#define MF_REGISTER_shmat		__MF_TYPE_GUESS
+
+
+#include <time.h>
+WRAPPER2(time_t, time, time_t *timep)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  if (NULL != timep)
+    MF_VALIDATE_EXTENT (timep, sizeof (*timep), __MF_CHECK_WRITE,
+      "time timep");
+  return time (timep);
+}
+
+
+WRAPPER2(char *, strerror, int errnum)
+{
+  char *p;
+  static char * last_strerror = NULL;
+
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  p = strerror (errnum);
+  if (last_strerror != NULL)
+    __mf_unregister (last_strerror, 0, __MF_TYPE_STATIC);
+  if (NULL != p)
+    __mf_register (p, strlen (p) + 1, __MF_TYPE_STATIC, "strerror result");
+  last_strerror = p;
+  return p;
+}
+
+
+
+/* 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;
+  FILE *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen path");
+
+  n = strlen (mode);
+  MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen mode");
+
+  p = fopen (path, mode);
+  if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+    __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;
+}
+
+
+#ifdef HAVE_FOPEN64
+WRAPPER2(FILE *, fopen64, const char *path, const char *mode)
+{
+  size_t n;
+  FILE *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 path");
+
+  n = strlen (mode);
+  MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "fopen64 mode");
+
+  p = fopen64 (path, mode);
+  if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+    __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;
+}
+#endif
+
+
+WRAPPER2(int, fclose, FILE *stream)
+{
+  int resp;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fclose stream");
+  resp = fclose (stream);
+#ifdef MF_REGISTER_fopen
+  __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen);
+#endif
+  unmkbuffer (stream);
+
+  return resp;
+}
+
+
+WRAPPER2(size_t, fread, void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fread stream");
+  MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_WRITE, "fread buffer");
+  return fread (ptr, size, nmemb, stream);
+}
+
+
+WRAPPER2(size_t, fwrite, const void *ptr, size_t size, size_t nmemb,
+	FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fwrite stream");
+  MF_VALIDATE_EXTENT (ptr, size * nmemb, __MF_CHECK_READ, "fwrite buffer");
+  return fwrite (ptr, size, nmemb, stream);
+}
+
+
+WRAPPER2(int, fgetc, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fgetc stream");
+  return fgetc (stream);
+}
+
+
+WRAPPER2(char *, fgets, char *s, int size, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fgets stream");
+  MF_VALIDATE_EXTENT (s, size, __MF_CHECK_WRITE, "fgets buffer");
+  return fgets (s, size, stream);
+}
+
+
+WRAPPER2(int, getc, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "getc stream");
+  return getc (stream);
+}
+
+
+WRAPPER2(char *, gets, char *s)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (s, 1, __MF_CHECK_WRITE, "gets buffer");
+  /* Avoid link-time warning... */
+  s = fgets (s, INT_MAX, stdin);
+  if (NULL != s) {	/* better late than never */
+    size_t n = strlen (s);
+    MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_WRITE, "gets buffer");
+  }
+  return s;
+}
+
+
+WRAPPER2(int, ungetc, int c, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+     "ungetc stream");
+  return ungetc (c, stream);
+}
+
+
+WRAPPER2(int, fputc, int c, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fputc stream");
+  return fputc (c, stream);
+}
+
+
+WRAPPER2(int, fputs, const char *s, FILE *stream)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (s);
+  MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "fputs buffer");
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fputs stream");
+  return fputs (s, stream);
+}
+
+
+WRAPPER2(int, putc, int c, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "putc stream");
+  return putc (c, stream);
+}
+
+
+WRAPPER2(int, puts, const char *s)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (s);
+  MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "puts buffer");
+  return puts (s);
+}
+
+
+WRAPPER2(void, clearerr, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "clearerr stream");
+  clearerr (stream);
+}
+
+
+WRAPPER2(int, feof, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "feof stream");
+  return feof (stream);
+}
+
+
+WRAPPER2(int, ferror, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "ferror stream");
+  return ferror (stream);
+}
+
+
+WRAPPER2(int, fileno, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fileno stream");
+  return fileno (stream);
+}
+
+
+WRAPPER2(int, printf, const char *format, ...)
+{
+  size_t n;
+  va_list ap;
+  int result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "printf format");
+  va_start (ap, format);
+  result = vprintf (format, ap);
+  va_end (ap);
+  return result;
+}
+
+
+WRAPPER2(int, fprintf, FILE *stream, const char *format, ...)
+{
+  size_t n;
+  va_list ap;
+  int result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fprintf stream");
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "fprintf format");
+  va_start (ap, format);
+  result = vfprintf (stream, format, ap);
+  va_end (ap);
+  return result;
+}
+
+
+WRAPPER2(int, sprintf, char *str, const char *format, ...)
+{
+  size_t n;
+  va_list ap;
+  int result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "sprintf str");
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "sprintf format");
+  va_start (ap, format);
+  result = vsprintf (str, format, ap);
+  va_end (ap);
+  n = strlen (str);
+  MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "sprintf str");
+  return result;
+}
+
+
+WRAPPER2(int, snprintf, char *str, size_t size, const char *format, ...)
+{
+  size_t n;
+  va_list ap;
+  int result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "snprintf str");
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "snprintf format");
+  va_start (ap, format);
+  result = vsnprintf (str, size, format, ap);
+  va_end (ap);
+  return result;
+}
+
+
+WRAPPER2(int, vprintf,  const char *format, va_list ap)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "vprintf format");
+  return vprintf (format, ap);
+}
+
+
+WRAPPER2(int, vfprintf, FILE *stream, const char *format, va_list ap)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "vfprintf stream");
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "vfprintf format");
+  return vfprintf (stream, format, ap);
+}
+
+
+WRAPPER2(int, vsprintf, char *str, const char *format, va_list ap)
+{
+  size_t n;
+  int result;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (str, 1, __MF_CHECK_WRITE, "vsprintf str");
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "vsprintf format");
+  result = vsprintf (str, format, ap);
+  n = strlen (str);
+  MF_VALIDATE_EXTENT (str, CLAMPADD(n, 1), __MF_CHECK_WRITE, "vsprintf str");
+  return result;
+}
+
+
+WRAPPER2(int, vsnprintf, char *str, size_t size, const char *format,
+	va_list ap)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (str, size, __MF_CHECK_WRITE, "vsnprintf str");
+  n = strlen (format);
+  MF_VALIDATE_EXTENT (format, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "vsnprintf format");
+  return vsnprintf (str, size, format, ap);
+}
+
+
+WRAPPER2(int , access, const char *path, int mode)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "access path");
+  return access (path, mode);
+}
+
+
+WRAPPER2(int , remove, const char *path)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "remove path");
+  return remove (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);
+}
+
+
+WRAPPER2(int, fseek, FILE *stream, long offset, int whence)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fseek stream");
+  return fseek (stream, offset, whence);
+}
+
+
+#ifdef HAVE_FSEEKO64
+WRAPPER2(int, fseeko64, FILE *stream, off64_t offset, int whence)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fseeko64 stream");
+  return fseeko64 (stream, offset, whence);
+}
+#endif
+
+
+WRAPPER2(long, ftell, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "ftell stream");
+  return ftell (stream);
+}
+
+
+#ifdef HAVE_FTELLO64
+WRAPPER2(off64_t, ftello64, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "ftello64 stream");
+  return ftello64 (stream);
+}
+#endif
+
+
+WRAPPER2(void, rewind, FILE *stream)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "rewind stream");
+  rewind (stream);
+}
+
+
+WRAPPER2(int, fgetpos, FILE *stream, fpos_t *pos)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fgetpos stream");
+  MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_WRITE, "fgetpos pos");
+  return fgetpos (stream, pos);
+}
+
+
+WRAPPER2(int, fsetpos, FILE *stream, fpos_t *pos)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "fsetpos stream");
+  MF_VALIDATE_EXTENT (pos, sizeof (*pos), __MF_CHECK_READ, "fsetpos pos");
+  return fsetpos (stream, pos);
+}
+
+
+WRAPPER2(int , stat, const char *path, struct stat *buf)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat path");
+  MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat buf");
+  return stat (path, buf);
+}
+
+
+#ifdef HAVE_STAT64
+WRAPPER2(int , stat64, const char *path, struct stat64 *buf)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "stat64 path");
+  MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "stat64 buf");
+  return stat64 (path, buf);
+}
+#endif
+
+
+WRAPPER2(int , fstat, int filedes, struct stat *buf)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "fstat buf");
+  return fstat (filedes, buf);
+}
+
+
+WRAPPER2(int , lstat, const char *path, struct stat *buf)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "lstat path");
+  MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ, "lstat buf");
+  return lstat (path, buf);
+}
+
+
+WRAPPER2(int , mkfifo, const char *path, mode_t mode)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "mkfifo path");
+  return mkfifo (path, mode);
+}
+
+
+#ifdef HAVE_DIRENT_H
+WRAPPER2(DIR *, opendir, const char *path)
+{
+  DIR *p;
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "opendir path");
+
+  p = opendir (path);
+  if (NULL != p) {
+#ifdef MF_REGISTER_opendir
+    __mf_register (p, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir,
+      "opendir result");
+#endif
+    MF_VALIDATE_EXTENT (p, MF_RESULT_SIZE_opendir, __MF_CHECK_WRITE,
+      "opendir result");
+  }
+  return p;
+}
+
+
+WRAPPER2(int, closedir, DIR *dir)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_WRITE, "closedir dir");
+#ifdef MF_REGISTER_opendir
+  __mf_unregister (dir, MF_RESULT_SIZE_opendir, MF_REGISTER_opendir);
+#endif
+  return closedir (dir);
+}
+
+
+WRAPPER2(struct dirent *, readdir, DIR *dir)
+{
+  struct dirent *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (dir, 0, __MF_CHECK_READ, "readdir dir");
+  p = readdir (dir);
+  if (NULL != p) {
+#ifdef MF_REGISTER_readdir
+    __mf_register (p, sizeof (*p), MF_REGISTER_readdir, "readdir result");
+#endif
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "readdir result");
+  }
+  return p;
+}
+#endif
+
+
+#ifdef HAVE_SYS_SOCKET_H
+
+WRAPPER2(int, recv, int s, void *buf, size_t len, int flags)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recv buf");
+  return recv (s, buf, len, flags);
+}
+
+
+WRAPPER2(int, recvfrom, int s, void *buf, size_t len, int flags,
+		struct sockaddr *from, socklen_t *fromlen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (buf, len, __MF_CHECK_WRITE, "recvfrom buf");
+  MF_VALIDATE_EXTENT (from, (size_t)*fromlen, __MF_CHECK_WRITE,
+    "recvfrom from");
+  return recvfrom (s, buf, len, flags, from, fromlen);
+}
+
+
+WRAPPER2(int, recvmsg, int s, struct msghdr *msg, int flags)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_WRITE, "recvmsg msg");
+  return recvmsg (s, msg, flags);
+}
+
+
+WRAPPER2(int, send, int s, const void *msg, size_t len, int flags)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "send msg");
+  return send (s, msg, len, flags);
+}
+
+
+WRAPPER2(int, sendto, int s, const void *msg, size_t len, int flags,
+		const struct sockaddr *to, socklen_t tolen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (msg, len, __MF_CHECK_READ, "sendto msg");
+  MF_VALIDATE_EXTENT (to, (size_t)tolen, __MF_CHECK_WRITE, "sendto to");
+  return sendto (s, msg, len, flags, to, tolen);
+}
+
+
+WRAPPER2(int, sendmsg, int s, const void *msg, int flags)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (msg, sizeof (*msg), __MF_CHECK_READ, "sendmsg msg");
+  return sendmsg (s, msg, flags);
+}
+
+
+WRAPPER2(int, setsockopt, int s, int level, int optname, const void *optval,
+	socklen_t optlen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (optval, (size_t)optlen, __MF_CHECK_READ,
+    "setsockopt optval");
+  return setsockopt (s, level, optname, optval, optlen);
+}
+
+
+WRAPPER2(int, getsockopt, int s, int level, int optname, void *optval,
+		socklen_t *optlen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (optval, (size_t)*optlen, __MF_CHECK_WRITE,
+    "getsockopt optval");
+  return getsockopt (s, level, optname, optval, optlen);
+}
+
+
+WRAPPER2(int, accept, int s, struct  sockaddr *addr, socklen_t *addrlen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  if (addr != NULL)
+    MF_VALIDATE_EXTENT (addr, (size_t)*addrlen, __MF_CHECK_WRITE, "accept addr");
+  return accept (s, addr, addrlen);
+}
+
+
+WRAPPER2(int, bind, int sockfd, struct  sockaddr *addr, socklen_t addrlen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_WRITE, "bind addr");
+  return bind (sockfd, addr, addrlen);
+}
+
+
+WRAPPER2(int, connect, int sockfd, const struct sockaddr  *addr,
+	socklen_t addrlen)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (addr, (size_t)addrlen, __MF_CHECK_READ,
+    "connect addr");
+  return connect (sockfd, addr, addrlen);
+}
+
+#endif /* HAVE_SYS_SOCKET_H */
+
+
+WRAPPER2(int, gethostname, char *name, size_t len)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (name, len, __MF_CHECK_WRITE, "gethostname name");
+  return gethostname (name, len);
+}
+
+
+#ifdef HAVE_SETHOSTNAME
+WRAPPER2(int, sethostname, const char *name, size_t len)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (name, len, __MF_CHECK_READ, "sethostname name");
+  return sethostname (name, len);
+}
+#endif
+
+
+#ifdef HAVE_NETDB_H
+
+WRAPPER2(struct hostent *, gethostbyname, const char *name)
+{
+  struct hostent *p;
+  char **ss;
+  char *s;
+  size_t n;
+  int nreg;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (name);
+  MF_VALIDATE_EXTENT (name, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "gethostbyname name");
+  p = gethostbyname (name);
+  if (NULL != p) {
+#ifdef MF_REGISTER_gethostbyname
+    __mf_register (p, sizeof (*p), MF_REGISTER_gethostbyname,
+      "gethostbyname result");
+#endif
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE,
+      "gethostbyname result");
+    if (NULL != (s = p->h_name)) {
+      n = strlen (s);
+      n = CLAMPADD(n, 1);
+#ifdef MF_REGISTER_gethostbyname_items
+      __mf_register (s, n, MF_REGISTER_gethostbyname_items,
+        "gethostbyname result->h_name");
+#endif
+      MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE,
+        "gethostbyname result->h_name");
+    }
+
+    if (NULL != (ss = p->h_aliases)) {
+      for (nreg = 1;; ++nreg) {
+        s = *ss++;
+        if (NULL == s)
+          break;
+        n = strlen (s);
+        n = CLAMPADD(n, 1);
+#ifdef MF_REGISTER_gethostbyname_items
+        __mf_register (s, n, MF_REGISTER_gethostbyname_items,
+          "gethostbyname result->h_aliases[]");
+#endif
+        MF_VALIDATE_EXTENT (s, n, __MF_CHECK_WRITE,
+          "gethostbyname result->h_aliases[]");
+      }
+      nreg *= sizeof (*p->h_aliases);
+#ifdef MF_REGISTER_gethostbyname_items
+      __mf_register (p->h_aliases, nreg, MF_REGISTER_gethostbyname_items,
+        "gethostbyname result->h_aliases");
+#endif
+      MF_VALIDATE_EXTENT (p->h_aliases, nreg, __MF_CHECK_WRITE,
+        "gethostbyname result->h_aliases");
+    }
+
+    if (NULL != (ss = p->h_addr_list)) {
+      for (nreg = 1;; ++nreg) {
+        s = *ss++;
+        if (NULL == s)
+          break;
+#ifdef MF_REGISTER_gethostbyname_items
+        __mf_register (s, p->h_length, MF_REGISTER_gethostbyname_items,
+          "gethostbyname result->h_addr_list[]");
+#endif
+        MF_VALIDATE_EXTENT (s, p->h_length, __MF_CHECK_WRITE,
+          "gethostbyname result->h_addr_list[]");
+      }
+      nreg *= sizeof (*p->h_addr_list);
+#ifdef MF_REGISTER_gethostbyname_items
+      __mf_register (p->h_addr_list, nreg, MF_REGISTER_gethostbyname_items,
+        "gethostbyname result->h_addr_list");
+#endif
+      MF_VALIDATE_EXTENT (p->h_addr_list, nreg, __MF_CHECK_WRITE,
+        "gethostbyname result->h_addr_list");
+    }
+  }
+  return p;
+}
+
+#endif /* HAVE_NETDB_H */
+
+
+#ifdef HAVE_SYS_WAIT_H
+
+WRAPPER2(pid_t, wait, int *status)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  if (NULL != status)
+    MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE,
+      "wait status");
+  return wait (status);
+}
+
+
+WRAPPER2(pid_t, waitpid, pid_t pid, int *status, int options)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  if (NULL != status)
+    MF_VALIDATE_EXTENT (status, sizeof (*status), __MF_CHECK_WRITE,
+      "waitpid status");
+  return waitpid (pid, status, options);
+}
+
+#endif /* HAVE_SYS_WAIT_H */
+
+
+WRAPPER2(FILE *, popen, const char *command, const char *mode)
+{
+  size_t n;
+  FILE *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (command);
+  MF_VALIDATE_EXTENT (command, CLAMPADD(n, 1), __MF_CHECK_READ, "popen path");
+
+  n = strlen (mode);
+  MF_VALIDATE_EXTENT (mode, CLAMPADD(n, 1), __MF_CHECK_READ, "popen mode");
+
+  p = popen (command, mode);
+  if (NULL != p) {
+#ifdef MF_REGISTER_fopen
+    __mf_register (p, sizeof (*p), MF_REGISTER_fopen, "popen result");
+#endif
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_WRITE, "popen result");
+  }
+  return p;
+}
+
+
+WRAPPER2(int, pclose, FILE *stream)
+{
+  int resp;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (stream, sizeof (*stream), __MF_CHECK_WRITE,
+    "pclose stream");
+  resp = pclose (stream);
+#ifdef MF_REGISTER_fopen
+  __mf_unregister (stream, sizeof (*stream), MF_REGISTER_fopen);
+#endif
+  return resp;
+}
+
+
+WRAPPER2(int, execve, const char *path, char *const argv [],
+	char *const envp[])
+{
+  size_t n;
+  char *const *p;
+  const char *s;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execve path");
+
+  for (p = argv;;) {
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *argv");
+    s = *p++;
+    if (NULL == s)
+      break;
+    n = strlen (s);
+    MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **argv");
+  }
+
+  for (p = envp;;) {
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execve *envp");
+    s = *p++;
+    if (NULL == s)
+      break;
+    n = strlen (s);
+    MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execve **envp");
+  }
+  return execve (path, argv, envp);
+}
+
+
+WRAPPER2(int, execv, const char *path, char *const argv [])
+{
+  size_t n;
+  char *const *p;
+  const char *s;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execv path");
+
+  for (p = argv;;) {
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execv *argv");
+    s = *p++;
+    if (NULL == s)
+      break;
+    n = strlen (s);
+    MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execv **argv");
+  }
+  return execv (path, argv);
+}
+
+
+WRAPPER2(int, execvp, const char *path, char *const argv [])
+{
+  size_t n;
+  char *const *p;
+  const char *s;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp path");
+
+  for (p = argv;;) {
+    MF_VALIDATE_EXTENT (p, sizeof (*p), __MF_CHECK_READ, "execvp *argv");
+    s = *p++;
+    if (NULL == s)
+      break;
+    n = strlen (s);
+    MF_VALIDATE_EXTENT (s, CLAMPADD(n, 1), __MF_CHECK_READ, "execvp **argv");
+  }
+  return execvp (path, argv);
+}
+
+
+WRAPPER2(int, system, const char *string)
+{
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (string);
+  MF_VALIDATE_EXTENT (string, CLAMPADD(n, 1), __MF_CHECK_READ,
+    "system string");
+  return system (string);
+}
+
+
+WRAPPER2(void *, dlopen, const char *path, int flags)
+{
+  void *p;
+  size_t n;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  n = strlen (path);
+  MF_VALIDATE_EXTENT (path, CLAMPADD(n, 1), __MF_CHECK_READ, "dlopen path");
+  p = dlopen (path, flags);
+  if (NULL != p) {
+#ifdef MF_REGISTER_dlopen
+    __mf_register (p, 0, MF_REGISTER_dlopen, "dlopen result");
+#endif
+    MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlopen result");
+  }
+  return p;
+}
+
+
+WRAPPER2(int, dlclose, void *handle)
+{
+  int resp;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlclose handle");
+  resp = dlclose (handle);
+#ifdef MF_REGISTER_dlopen
+  __mf_unregister (handle, 0, MF_REGISTER_dlopen);
+#endif
+  return resp;
+}
+
+
+WRAPPER2(char *, dlerror)
+{
+  char *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  p = dlerror ();
+  if (NULL != p) {
+    size_t n;
+    n = strlen (p);
+    n = CLAMPADD(n, 1);
+#ifdef MF_REGISTER_dlerror
+    __mf_register (p, n, MF_REGISTER_dlerror, "dlerror result");
+#endif
+    MF_VALIDATE_EXTENT (p, n, __MF_CHECK_WRITE, "dlerror result");
+  }
+  return p;
+}
+
+
+WRAPPER2(void *, dlsym, void *handle, char *symbol)
+{
+  size_t n;
+  void *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (handle, 0, __MF_CHECK_READ, "dlsym handle");
+  n = strlen (symbol);
+  MF_VALIDATE_EXTENT (symbol, CLAMPADD(n, 1), __MF_CHECK_READ, "dlsym symbol");
+  p = dlsym (handle, symbol);
+  if (NULL != p) {
+#ifdef MF_REGISTER_dlsym
+    __mf_register (p, 0, MF_REGISTER_dlsym, "dlsym result");
+#endif
+    MF_VALIDATE_EXTENT (p, 0, __MF_CHECK_WRITE, "dlsym result");
+  }
+  return p;
+}
+
+
+#if defined (HAVE_SYS_IPC_H) && defined (HAVE_SYS_SEM_H) && defined (HAVE_SYS_SHM_H)
+
+WRAPPER2(int, semop, int semid, struct sembuf *sops, unsigned nsops)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  MF_VALIDATE_EXTENT (sops, sizeof (*sops) * nsops, __MF_CHECK_READ,
+    "semop sops");
+  return semop (semid, sops, nsops);
+}
+
+
+#ifndef HAVE_UNION_SEMUN
+union semun {
+	int val;			/* value for SETVAL */
+	struct semid_ds *buf;		/* buffer for IPC_STAT, IPC_SET */
+	unsigned short int *array;	/* array for GETALL, SETALL */
+	struct seminfo *__buf;		/* buffer for IPC_INFO */
+};
+#endif
+WRAPPER2(int, semctl, int semid, int semnum, int cmd, union semun arg)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  switch (cmd) {
+  case IPC_STAT:
+    MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_WRITE,
+      "semctl buf");
+    break;
+  case IPC_SET:
+    MF_VALIDATE_EXTENT (arg.buf, sizeof (*arg.buf), __MF_CHECK_READ,
+      "semctl buf");
+    break;
+  case GETALL:
+    MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_WRITE,
+      "semctl array");
+  case SETALL:
+    MF_VALIDATE_EXTENT (arg.array, sizeof (*arg.array), __MF_CHECK_READ,
+      "semctl array");
+    break;
+#ifdef IPC_INFO
+  /* FreeBSD 5.1 And Cygwin headers include IPC_INFO but not the __buf field.  */
+#if !defined(__FreeBSD__) && !defined(__CYGWIN__)
+  case IPC_INFO:
+    MF_VALIDATE_EXTENT (arg.__buf, sizeof (*arg.__buf), __MF_CHECK_WRITE,
+      "semctl __buf");
+    break;
+#endif
+#endif
+  default:
+    break;
+  }
+  return semctl (semid, semnum, cmd, arg);
+}
+
+
+WRAPPER2(int, shmctl, int shmid, int cmd, struct shmid_ds *buf)
+{
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  switch (cmd) {
+  case IPC_STAT:
+    MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_WRITE,
+      "shmctl buf");
+    break;
+  case IPC_SET:
+    MF_VALIDATE_EXTENT (buf, sizeof (*buf), __MF_CHECK_READ,
+      "shmctl buf");
+    break;
+  default:
+    break;
+  }
+  return shmctl (shmid, cmd, buf);
+}
+
+
+WRAPPER2(void *, shmat, int shmid, const void *shmaddr, int shmflg)
+{
+  void *p;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  p = shmat (shmid, shmaddr, shmflg);
+#ifdef MF_REGISTER_shmat
+  if (NULL != p) {
+    struct shmid_ds buf;
+    __mf_register (p, shmctl (shmid, IPC_STAT, &buf) ? 0 : buf.shm_segsz,
+      MF_REGISTER_shmat, "shmat result");
+  }
+#endif
+  return p;
+}
+
+
+WRAPPER2(int, shmdt, const void *shmaddr)
+{
+  int resp;
+  TRACE ("%s\n", __PRETTY_FUNCTION__);
+  resp = shmdt (shmaddr);
+#ifdef MF_REGISTER_shmat
+  __mf_unregister ((void *)shmaddr, 0, MF_REGISTER_shmat);
+#endif
+  return resp;
+}
+
+
+#endif /* HAVE_SYS_IPC/SEM/SHM_H */
+
+
+
+/* ctype stuff.  This is host-specific by necessity, as the arrays
+   that is used by most is*()/to*() macros are implementation-defined.  */
+
+/* GLIBC 2.3 */
+#ifdef HAVE___CTYPE_B_LOC
+WRAPPER2(unsigned short **, __ctype_b_loc, void)
+{
+  static unsigned short * last_buf = (void *) 0;
+  static unsigned short ** last_ptr = (void *) 0;
+  unsigned short ** ptr = (unsigned short **) __ctype_b_loc ();
+  unsigned short * buf = * ptr;
+  if (ptr != last_ptr)
+    {
+      /* XXX: unregister last_ptr? */
+      last_ptr = ptr;
+      __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_b_loc **");
+    }
+  if (buf != last_buf)
+    {
+      last_buf = buf;
+      __mf_register ((void *) (last_buf - 128), 384 * sizeof(unsigned short), __MF_TYPE_STATIC,
+                     "ctype_b_loc []");
+    }
+  return ptr;
+}
+#endif
+
+#ifdef HAVE___CTYPE_TOUPPER_LOC
+WRAPPER2(int **, __ctype_toupper_loc, void)
+{
+  static int * last_buf = (void *) 0;
+  static int ** last_ptr = (void *) 0;
+  int ** ptr = (int **) __ctype_toupper_loc ();
+  int * buf = * ptr;
+  if (ptr != last_ptr)
+    {
+      /* XXX: unregister last_ptr? */
+      last_ptr = ptr;
+      __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_toupper_loc **");
+    }
+  if (buf != last_buf)
+    {
+      last_buf = buf;
+      __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC,
+                     "ctype_toupper_loc []");
+    }
+  return ptr;
+}
+#endif
+
+#ifdef HAVE___CTYPE_TOLOWER_LOC
+WRAPPER2(int **, __ctype_tolower_loc, void)
+{
+  static int * last_buf = (void *) 0;
+  static int ** last_ptr = (void *) 0;
+  int ** ptr = (int **) __ctype_tolower_loc ();
+  int * buf = * ptr;
+  if (ptr != last_ptr)
+    {
+      /* XXX: unregister last_ptr? */
+      last_ptr = ptr;
+      __mf_register (last_ptr, sizeof(last_ptr), __MF_TYPE_STATIC, "ctype_tolower_loc **");
+    }
+  if (buf != last_buf)
+    {
+      last_buf = buf;
+      __mf_register ((void *) (last_buf - 128), 384 * sizeof(int), __MF_TYPE_STATIC,
+                     "ctype_tolower_loc []");
+    }
+  return ptr;
+}
+#endif
+
+
+/* passwd/group related functions.  These register every (static) pointer value returned,
+   and rely on libmudflap's quiet toleration of duplicate static registrations.  */
+
+#ifdef HAVE_GETLOGIN
+WRAPPER2(char *, getlogin, void)
+{
+  char *buf = getlogin ();
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getlogin() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_CUSERID
+WRAPPER2(char *, cuserid, char * buf)
+{
+  if (buf != NULL)
+    {
+      MF_VALIDATE_EXTENT(buf, L_cuserid, __MF_CHECK_WRITE,
+                         "cuserid destination");
+      return cuserid (buf);
+    }
+  buf = cuserid (NULL);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getcuserid() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPWNAM
+WRAPPER2(struct passwd *, getpwnam, const char *name)
+{
+  struct passwd *buf;
+  MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+                     "getpwnam name");
+  buf = getpwnam (name);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getpw*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPWUID
+WRAPPER2(struct passwd *, getpwuid, uid_t uid)
+{
+  struct passwd *buf;
+  buf = getpwuid (uid);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getpw*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETGRNAM
+WRAPPER2(struct group *, getgrnam, const char *name)
+{
+  struct group *buf;
+  MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+                     "getgrnam name");
+  buf = getgrnam (name);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getgr*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETGRGID
+WRAPPER2(struct group *, getgrgid, uid_t uid)
+{
+  struct group *buf;
+  buf = getgrgid (uid);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getgr*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETSERVENT
+WRAPPER2(struct servent *, getservent, void)
+{
+  struct servent *buf;
+  buf = getservent ();
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getserv*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETSERVBYNAME
+WRAPPER2(struct servent *, getservbyname, const char *name, const char *proto)
+{
+  struct servent *buf;
+  MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+                     "getservbyname name");
+  MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ,
+                     "getservbyname proto");
+  buf = getservbyname (name, proto);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getserv*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETSERVBYPORT
+WRAPPER2(struct servent *, getservbyport, int port, const char *proto)
+{
+  struct servent *buf;
+  MF_VALIDATE_EXTENT(proto, strlen(proto)+1, __MF_CHECK_READ,
+                     "getservbyport proto");
+  buf = getservbyport (port, proto);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getserv*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GAI_STRERROR
+WRAPPER2(const char *, gai_strerror, int errcode)
+{
+  const char *buf;
+  buf = gai_strerror (errcode);
+  if (buf != NULL)
+    __mf_register ((void *) buf, strlen(buf)+1, __MF_TYPE_STATIC,
+                   "gai_strerror() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETMNTENT
+WRAPPER2(struct mntent *, getmntent, FILE *filep)
+{
+  struct mntent *m;
+  static struct mntent *last = NULL;
+
+  MF_VALIDATE_EXTENT (filep, sizeof (*filep), __MF_CHECK_WRITE,
+    "getmntent stream");
+#define UR(field) __mf_unregister(last->field, strlen (last->field)+1, __MF_TYPE_STATIC)
+  if (last)
+    {
+      UR (mnt_fsname);
+      UR (mnt_dir);
+      UR (mnt_type);
+      UR (mnt_opts);
+      __mf_unregister (last, sizeof (*last), __MF_TYPE_STATIC);
+    }
+#undef UR
+
+  m = getmntent (filep);
+  last = m;
+
+#define R(field) __mf_register(last->field, strlen (last->field)+1, __MF_TYPE_STATIC, "mntent " #field)
+  if (m)
+    {
+      R (mnt_fsname);
+      R (mnt_dir);
+      R (mnt_type);
+      R (mnt_opts);
+      __mf_register (last, sizeof (*last), __MF_TYPE_STATIC, "getmntent result");
+    }
+#undef R
+
+  return m;
+}
+#endif
+
+
+#ifdef HAVE_INET_NTOA
+WRAPPER2(char *, inet_ntoa, struct in_addr in)
+{
+  static char *last_buf = NULL;
+  char *buf;
+  if (last_buf)
+    __mf_unregister (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC);
+  buf = inet_ntoa (in);
+  last_buf = buf;
+  if (buf)
+    __mf_register (last_buf, strlen (last_buf)+1, __MF_TYPE_STATIC, "inet_ntoa result");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPROTOENT
+WRAPPER2(struct protoent *, getprotoent, void)
+{
+  struct protoent *buf;
+  buf = getprotoent ();
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC, "getproto*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPROTOBYNAME
+WRAPPER2(struct protoent *, getprotobyname, const char *name)
+{
+  struct protoent *buf;
+  MF_VALIDATE_EXTENT(name, strlen(name)+1, __MF_CHECK_READ,
+                     "getprotobyname name");
+  buf = getprotobyname (name);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getproto*() return");
+  return buf;
+}
+#endif
+
+
+#ifdef HAVE_GETPROTOBYNUMBER
+WRAPPER2(struct protoent *, getprotobynumber, int port)
+{
+  struct protoent *buf;
+  buf = getprotobynumber (port);
+  if (buf != NULL)
+    __mf_register (buf, sizeof(*buf), __MF_TYPE_STATIC,
+                   "getproto*() return");
+  return buf;
+}
+#endif

Added: llvm-gcc-4.2/trunk/libmudflap/mf-hooks3.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/mf-hooks3.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/mf-hooks3.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/mf-hooks3.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,288 @@
+/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
+   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Contributed by Frank Ch. Eigler <fche at redhat.com>
+   and Graydon Hoare <graydon at redhat.com>
+
+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 2, or (at your option) any later
+version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+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 COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+
+#include "config.h"
+
+#ifndef HAVE_SOCKLEN_T
+#define socklen_t int
+#endif
+
+/* These attempt to coax various unix flavours to declare all our
+   needed tidbits in the system headers.  */
+#if !defined(__FreeBSD__) && !defined(__APPLE__)
+#define _POSIX_SOURCE
+#endif /* Some BSDs break <sys/socket.h> if this is defined. */
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE
+#define _BSD_TYPES
+#define __EXTENSIONS__
+#define _ALL_SOURCE
+#define _LARGE_FILE_API
+#define _XOPEN_SOURCE_EXTENDED 1
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <stdbool.h>
+
+#include "mf-runtime.h"
+#include "mf-impl.h"
+
+#ifdef _MUDFLAP
+#error "Do not compile this file with -fmudflap!"
+#endif
+
+#ifndef LIBMUDFLAPTH
+#error "pthreadstuff is to be included only in libmudflapth"
+#endif
+
+/* ??? Why isn't this done once in the header files.  */
+DECLARE(void *, malloc, size_t sz);
+DECLARE(void, free, void *ptr);
+DECLARE(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr,
+	void * (*start) (void *), void *arg);
+
+
+/* Multithreading support hooks.  */
+
+
+#ifndef HAVE_TLS
+/* We don't have TLS.  Ordinarily we could use pthread keys, but since we're
+   commandeering malloc/free that presents a few problems.  The first is that
+   we'll recurse from __mf_get_state to pthread_setspecific to malloc back to
+   __mf_get_state during thread startup.  This can be solved with clever uses
+   of a mutex.  The second problem is that thread shutdown is indistinguishable
+   from thread startup, since libpthread is deallocating our state variable.
+   I've no good solution for this.
+
+   Which leaves us to handle this mess by totally by hand.  */
+
+/* Yes, we want this prime.  If pthread_t is a pointer, it's almost always
+   page aligned, and if we use a smaller power of 2, this results in "%N"
+   being the worst possible hash -- all threads hash to zero.  */
+#define LIBMUDFLAPTH_THREADS_MAX 1021
+
+struct mf_thread_data
+{
+  pthread_t self;
+  unsigned char used_p;
+  unsigned char state;
+};
+
+static struct mf_thread_data mf_thread_data[LIBMUDFLAPTH_THREADS_MAX];
+static pthread_mutex_t mf_thread_data_lock = PTHREAD_MUTEX_INITIALIZER;
+
+#define PTHREAD_HASH(p) ((unsigned long) (p) % LIBMUDFLAPTH_THREADS_MAX)
+
+static struct mf_thread_data *
+__mf_find_threadinfo (int alloc)
+{
+  pthread_t self = pthread_self ();
+  unsigned long hash = PTHREAD_HASH (self);
+  unsigned long rehash;
+
+#ifdef __alpha__
+  /* Alpha has the loosest memory ordering rules of all.  We need a memory
+     barrier to flush the reorder buffer before considering a *read* of a
+     shared variable.  Since we're not always taking a lock, we have to do
+     this by hand.  */
+  __sync_synchronize ();
+#endif
+
+  rehash = hash;
+  while (1)
+    {
+      if (mf_thread_data[rehash].used_p && mf_thread_data[rehash].self == self)
+	return &mf_thread_data[rehash];
+
+      rehash += 7;
+      if (rehash >= LIBMUDFLAPTH_THREADS_MAX)
+	rehash -= LIBMUDFLAPTH_THREADS_MAX;
+      if (rehash == hash)
+	break;
+    }
+
+  if (alloc)
+    {
+      pthread_mutex_lock (&mf_thread_data_lock);
+
+      rehash = hash;
+      while (1)
+	{
+	  if (!mf_thread_data[rehash].used_p)
+	    {
+	      mf_thread_data[rehash].self = self;
+	      __sync_synchronize ();
+	      mf_thread_data[rehash].used_p = 1;
+
+	      pthread_mutex_unlock (&mf_thread_data_lock);
+	      return &mf_thread_data[rehash];
+	    }
+
+	  rehash += 7;
+	  if (rehash >= LIBMUDFLAPTH_THREADS_MAX)
+	    rehash -= LIBMUDFLAPTH_THREADS_MAX;
+	  if (rehash == hash)
+	    break;
+	}
+
+      pthread_mutex_unlock (&mf_thread_data_lock);
+    }
+
+  return NULL;
+}
+
+enum __mf_state_enum
+__mf_get_state (void)
+{
+  struct mf_thread_data *data = __mf_find_threadinfo (0);
+  if (data)
+    return data->state;
+
+  /* If we've never seen this thread before, consider it to be in the
+     reentrant state.  The state gets reset to active for the main thread
+     in __mf_init, and for child threads in __mf_pthread_spawner.
+
+     The trickiest bit here is that the LinuxThreads pthread_manager thread
+     should *always* be considered to be reentrant, so that none of our 
+     hooks actually do anything.  Why?  Because that thread isn't a real
+     thread from the point of view of the thread library, and so lots of
+     stuff isn't initialized, leading to SEGV very quickly.  Even calling
+     pthread_self is a bit suspect, but it happens to work.  */
+
+  return reentrant;
+}
+
+void
+__mf_set_state (enum __mf_state_enum new_state)
+{
+  struct mf_thread_data *data = __mf_find_threadinfo (1);
+  data->state = new_state;
+}
+#endif
+
+/* The following two functions are used only with __mf_opts.heur_std_data.
+   We're interested in recording the location of the thread-local errno
+   variable.
+
+   Note that this doesn't handle TLS references in general; we have no
+   visibility into __tls_get_data for when that memory is allocated at
+   runtime.  Hopefully we get to see the malloc or mmap operation that
+   eventually allocates the backing store.  */
+
+/* Describe the startup information for a new user thread.  */
+struct mf_thread_start_info
+{
+  /* The user's thread entry point and argument.  */
+  void * (*user_fn)(void *);
+  void *user_arg;
+};
+
+
+static void
+__mf_pthread_cleanup (void *arg)
+{
+  if (__mf_opts.heur_std_data)
+    __mf_unregister (&errno, sizeof (errno), __MF_TYPE_GUESS);
+
+#ifndef HAVE_TLS
+  struct mf_thread_data *data = __mf_find_threadinfo (0);
+  if (data)
+    data->used_p = 0;
+#endif
+}
+
+
+static void *
+__mf_pthread_spawner (void *arg)
+{
+  void *result = NULL;
+
+  __mf_set_state (active);
+
+  /* NB: We could use __MF_TYPE_STATIC here, but we guess that the thread
+     errno is coming out of some dynamically allocated pool that we already
+     know of as __MF_TYPE_HEAP. */
+  if (__mf_opts.heur_std_data)
+    __mf_register (&errno, sizeof (errno), __MF_TYPE_GUESS,
+		   "errno area (thread)");
+
+  /* We considered using pthread_key_t objects instead of these
+     cleanup stacks, but they were less cooperative with the
+     interposed malloc hooks in libmudflap.  */
+  /* ??? The pthread_key_t problem is solved above...  */
+  pthread_cleanup_push (__mf_pthread_cleanup, NULL);
+
+  /* Extract given entry point and argument.  */
+  struct mf_thread_start_info *psi = arg;
+  void * (*user_fn)(void *) = psi->user_fn;
+  void *user_arg = psi->user_arg;
+  CALL_REAL (free, arg);
+
+  result = (*user_fn)(user_arg);
+
+  pthread_cleanup_pop (1 /* execute */);
+
+  return result;
+}
+
+
+#if PIC
+/* A special bootstrap variant. */
+int
+__mf_0fn_pthread_create (pthread_t *thr, const pthread_attr_t *attr,
+			 void * (*start) (void *), void *arg)
+{
+  return -1;
+}
+#endif
+
+
+#undef pthread_create
+WRAPPER(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr,
+	 void * (*start) (void *), void *arg)
+{
+  struct mf_thread_start_info *si;
+
+  TRACE ("pthread_create\n");
+
+  /* Fill in startup-control fields.  */
+  si = CALL_REAL (malloc, sizeof (*si));
+  si->user_fn = start;
+  si->user_arg = arg;
+
+  /* Actually create the thread.  */
+  return CALL_REAL (pthread_create, thr, attr, __mf_pthread_spawner, si);
+}

Added: llvm-gcc-4.2/trunk/libmudflap/mf-impl.h
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/mf-impl.h?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/mf-impl.h (added)
+++ llvm-gcc-4.2/trunk/libmudflap/mf-impl.h Thu Nov  8 16:56:19 2007
@@ -0,0 +1,416 @@
+/* Implementation header for mudflap runtime library.
+   Mudflap: narrow-pointer bounds-checking by tree rewriting.
+   Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+   Contributed by Frank Ch. Eigler <fche at redhat.com>
+   and Graydon Hoare <graydon at redhat.com>
+
+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 2, or (at your option) any later
+version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+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 COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+#ifndef __MF_IMPL_H
+#define __MF_IMPL_H
+
+#ifdef _MUDFLAP
+#error "Do not compile this file with -fmudflap!"
+#endif
+
+#if HAVE_PTHREAD_H
+#include <pthread.h>
+#elif LIBMUDFLAPTH
+#error "Cannot build libmudflapth without pthread.h."
+#endif
+
+#if HAVE_STDINT_H
+#include <stdint.h>
+#else
+typedef __mf_uintptr_t uintptr_t;
+#endif
+
+/* Private definitions related to mf-runtime.h  */
+
+#define __MF_TYPE_MAX_CEM  __MF_TYPE_STACK  /* largest type# for the cemetary */
+#define __MF_TYPE_MAX __MF_TYPE_GUESS
+
+
+#ifndef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+/* Address calculation macros.  */
+
+#define MINPTR ((uintptr_t) 0)
+#define MAXPTR (~ (uintptr_t) 0)
+
+/* Clamp the addition/subtraction of uintptr_t's to [MINPTR,MAXPTR] */
+#define CLAMPSUB(ptr,offset) (((uintptr_t) ptr) >= (offset) ? ((uintptr_t) ptr)-((uintptr_t) offset) : MINPTR)
+#define CLAMPADD(ptr,offset) (((uintptr_t) ptr) <= MAXPTR-(offset) ? ((uintptr_t) ptr)+((uintptr_t) offset) : MAXPTR)
+#define CLAMPSZ(ptr,size) ((size) ? (((uintptr_t) ptr) <= MAXPTR-(size)+1 ? ((uintptr_t) ptr)+((uintptr_t) size) - 1 : MAXPTR) : ((uintptr_t) ptr))
+
+#define __MF_CACHE_INDEX(ptr) ((((uintptr_t) (ptr)) >> __mf_lc_shift) & __mf_lc_mask)
+#define __MF_CACHE_MISS_P(ptr,sz) ({ \
+             struct __mf_cache *elem = & __mf_lookup_cache[__MF_CACHE_INDEX((ptr))]; \
+             ((elem->low > (uintptr_t) (ptr)) ||                  \
+	      (elem->high < (CLAMPADD((uintptr_t) (ptr), (uintptr_t) CLAMPSUB(sz,1) )))); })
+/* XXX: the above should use CLAMPSZ () */
+
+
+
+/* Private functions. */
+
+extern void __mf_violation (void *ptr, size_t sz,
+			    uintptr_t pc, const char *location,
+			    int type);
+extern size_t __mf_backtrace (char ***, void *, unsigned);
+extern int __mf_heuristic_check (uintptr_t, uintptr_t);
+
+/* ------------------------------------------------------------------------ */
+/* Type definitions. */
+/* ------------------------------------------------------------------------ */
+
+/* The mf_state type codes describe recursion and initialization order.
+
+   reentrant means we are inside a mf-runtime support routine, such as
+   __mf_register, and thus there should be no calls to any wrapped functions,
+   such as the wrapped malloc.  This indicates a bug if it occurs.
+   in_malloc means we are inside a real malloc call inside a wrapped malloc
+   call, and thus there should be no calls to any wrapped functions like the
+   wrapped mmap.  This happens on some systems due to how the system libraries
+   are constructed.  */
+
+enum __mf_state_enum { active, reentrant, in_malloc }; 
+
+/* The __mf_options structure records optional or tunable aspects of the
+ mudflap library's behavior. There is a single global instance of this
+ structure which is populated from user input (in an environment variable)
+ when the library initializes. */
+
+struct __mf_options
+{
+  /* Emit a trace message for each call. */
+  unsigned trace_mf_calls;
+
+  /* Collect and emit statistics. */
+  unsigned collect_stats;
+
+  /* Set up a SIGUSR1 -> __mf_report handler. */
+  unsigned sigusr1_report;
+
+  /* Execute internal checking code. */
+  unsigned internal_checking;
+
+  /* Age object liveness periodically. */
+  unsigned tree_aging;
+
+  /* Adapt the lookup cache to working set. */
+  unsigned adapt_cache;
+
+  /* Print list of leaked heap objects on shutdown. */
+  unsigned print_leaks;
+
+  /* Detect reads of uninitialized objects. */
+  unsigned check_initialization;
+
+  /* Print verbose description of violations. */
+  unsigned verbose_violations;
+
+  /* Abbreviate duplicate object descriptions.  */
+  unsigned abbreviate;
+
+  /* Emit internal tracing message. */
+  unsigned verbose_trace;
+
+  /* Wipe stack/heap objects upon unwind.  */
+  unsigned wipe_stack;
+  unsigned wipe_heap;
+
+  /* Maintain a queue of this many deferred free()s,
+     to trap use of freed memory. */
+  unsigned free_queue_length;
+
+  /* Maintain a history of this many past unregistered objects. */
+  unsigned persistent_count;
+
+  /* Pad allocated extents by this many bytes on either side. */
+  unsigned crumple_zone;
+
+  /* Maintain this many stack frames for contexts. */
+  unsigned backtrace;
+
+  /* Ignore read operations even if mode_check is in effect.  */
+  unsigned ignore_reads;
+
+  /* Collect register/unregister timestamps.  */
+  unsigned timestamps;
+
+#ifdef LIBMUDFLAPTH
+  /* Thread stack size.  */
+  unsigned thread_stack;
+#endif
+
+  /* Major operation mode */
+#define mode_nop 0      /* Do nothing.  */
+#define mode_populate 1 /* Populate tree but do not check for violations.  */
+#define mode_check 2    /* Populate and check for violations (normal).  */
+#define mode_violate 3  /* Trigger a violation on every call (diagnostic).  */
+  unsigned mudflap_mode;
+
+  /* How to handle a violation. */
+#define viol_nop 0   /* Return control to application. */
+#define viol_segv 1  /* Signal self with segv. */
+#define viol_abort 2 /* Call abort (). */
+#define viol_gdb 3   /* Fork a debugger on self */
+  unsigned violation_mode;
+
+  /* Violation heuristics selection. */
+  unsigned heur_stack_bound; /* allow current stack region */
+  unsigned heur_proc_map;  /* allow & cache /proc/self/map regions.  */
+  unsigned heur_start_end; /* allow _start .. _end */
+  unsigned heur_std_data; /* allow & cache stdlib data */
+};
+
+
+#ifdef PIC
+
+/* This is a table of dynamically resolved function pointers. */
+
+struct __mf_dynamic_entry
+{
+  void *pointer;
+  char *name;
+  char *version;
+};
+
+/* The definition of the array (mf-runtime.c) must match the enums!  */
+extern struct __mf_dynamic_entry __mf_dynamic[];
+enum __mf_dynamic_index
+{
+  dyn_calloc, dyn_free, dyn_malloc, dyn_mmap,
+  dyn_munmap, dyn_realloc,
+  dyn_INITRESOLVE,  /* Marker for last init-time resolution. */
+#ifdef LIBMUDFLAPTH
+  dyn_pthread_create
+#endif
+};
+
+#endif /* PIC */
+
+/* ------------------------------------------------------------------------ */
+/* Private global variables. */
+/* ------------------------------------------------------------------------ */
+
+#ifdef LIBMUDFLAPTH
+extern pthread_mutex_t __mf_biglock;
+#define LOCKTH() do { extern unsigned long __mf_lock_contention; \
+                      int rc = pthread_mutex_trylock (& __mf_biglock); \
+                      if (rc) { __mf_lock_contention ++; \
+                                rc = pthread_mutex_lock (& __mf_biglock); } \
+                      assert (rc==0); } while (0)
+#define UNLOCKTH() do { int rc = pthread_mutex_unlock (& __mf_biglock); \
+                        assert (rc==0); } while (0)
+#else
+#define LOCKTH() do {} while (0)
+#define UNLOCKTH() do {} while (0)
+#endif
+
+#if defined(LIBMUDFLAPTH) && !defined(HAVE_TLS)
+extern enum __mf_state_enum __mf_get_state (void);
+extern void __mf_set_state (enum __mf_state_enum);
+#else
+# ifdef LIBMUDFLAPTH
+extern __thread enum __mf_state_enum __mf_state_1;
+# else
+extern enum __mf_state_enum __mf_state_1;
+# endif
+static inline enum __mf_state_enum __mf_get_state (void)
+{
+  return __mf_state_1;
+}
+static inline void __mf_set_state (enum __mf_state_enum s)
+{
+  __mf_state_1 = s;
+}
+#endif
+
+extern int __mf_starting_p;
+extern struct __mf_options __mf_opts;
+
+/* ------------------------------------------------------------------------ */
+/* Utility macros. */
+/* ------------------------------------------------------------------------ */
+
+#define UNLIKELY(e) (__builtin_expect (!!(e), 0))
+#define LIKELY(e) (__builtin_expect (!!(e), 1))
+#define STRINGIFY2(e) #e
+#define STRINGIFY(e) STRINGIFY2(e)
+
+#ifdef LIBMUDFLAPTH
+#define VERBOSE_TRACE(...) \
+  do { if (UNLIKELY (__mf_opts.verbose_trace)) {  \
+      fprintf (stderr, "mf(%u): ", (unsigned) pthread_self ()); \
+      fprintf (stderr, __VA_ARGS__); \
+    } } while (0)
+#define TRACE(...) \
+  do { if (UNLIKELY (__mf_opts.trace_mf_calls)) { \
+      fprintf (stderr, "mf(%u): ", (unsigned) pthread_self ()); \
+      fprintf (stderr, __VA_ARGS__); \
+    } } while (0)
+#else
+#define VERBOSE_TRACE(...) \
+  do { if (UNLIKELY (__mf_opts.verbose_trace)) {  \
+      fprintf (stderr, "mf: "); \
+      fprintf (stderr, __VA_ARGS__); \
+    } } while (0)
+#define TRACE(...) \
+  do { if (UNLIKELY (__mf_opts.trace_mf_calls)) { \
+      fprintf (stderr, "mf: "); \
+      fprintf (stderr, __VA_ARGS__); \
+    } } while (0)
+#endif
+
+
+#define __MF_PERSIST_MAX 256
+#define __MF_FREEQ_MAX 256
+
+/*
+   Wrapping and redirection:
+
+   Mudflap redirects a number of libc functions into itself, for "cheap"
+   verification (eg. strcpy, bzero, memcpy) and also to register /
+   unregister regions of memory as they are manipulated by the program
+   (eg. malloc/free, mmap/munmap).
+
+   There are two methods of wrapping.
+
+   (1) The static method involves a list of -wrap=foo flags being passed to
+   the linker, which then links references to "foo" to the symbol
+   "__wrap_foo", and links references to "__real_foo" to the symbol "foo".
+   When compiled without -DPIC, libmudflap.a contains such __wrap_foo
+   functions which delegate to __real_foo functions in libc to get their
+   work done.
+
+   (2) The dynamic method involves providing a definition of symbol foo in
+   libmudflap.so and linking it earlier in the compiler command line,
+   before libc.so. The function "foo" in libmudflap must then call
+   dlsym(RTLD_NEXT, "foo") to acquire a pointer to the "real" libc foo, or
+   at least the "next" foo in the dynamic link resolution order.
+
+   We switch between these two techniques by the presence of the -DPIC
+   #define passed in by libtool when building libmudflap.
+*/
+
+
+#ifdef PIC
+
+extern void __mf_resolve_single_dynamic (struct __mf_dynamic_entry *);
+
+#define _GNU_SOURCE
+#include <dlfcn.h>
+
+#define WRAPPER(ret, fname, ...)                      \
+ret __wrap_ ## fname (__VA_ARGS__)                    \
+    __attribute__ (( alias  (#fname)  ));             \
+ret __real_ ## fname (__VA_ARGS__)                    \
+    __attribute__ (( alias  (#fname)  ));             \
+ret fname (__VA_ARGS__)
+#define DECLARE(ty, fname, ...)                       \
+ typedef ty (*__mf_fn_ ## fname) (__VA_ARGS__);       \
+ extern ty __mf_0fn_ ## fname (__VA_ARGS__);
+#define CALL_REAL(fname, ...)                         \
+  ({__mf_starting_p \
+     ? __mf_0fn_ ## fname (__VA_ARGS__) \
+    : (__mf_resolve_single_dynamic (& __mf_dynamic[dyn_ ## fname]), \
+       (((__mf_fn_ ## fname)(__mf_dynamic[dyn_ ## fname].pointer)) (__VA_ARGS__)));})
+#define CALL_BACKUP(fname, ...)                       \
+  __mf_0fn_ ## fname(__VA_ARGS__)
+
+#else /* not PIC --> static library */
+
+#define WRAPPER(ret, fname, ...)            \
+ret __wrap_ ## fname (__VA_ARGS__)
+#define DECLARE(ty, fname, ...)             \
+ extern ty __real_ ## fname (__VA_ARGS__)
+#define CALL_REAL(fname, ...)               \
+ __real_ ## fname (__VA_ARGS__)
+#define CALL_BACKUP(fname, ...)             \
+  __real_ ## fname(__VA_ARGS__)
+
+#endif /* PIC */
+
+/* WRAPPER2 is for functions intercepted via macros at compile time. */
+#define WRAPPER2(ret, fname, ...)                     \
+ret __mfwrap_ ## fname (__VA_ARGS__)
+
+
+/* Utility macros for mf-hooks*.c */
+
+#define MF_VALIDATE_EXTENT(value,size,acc,context) \
+ do { \
+  if (UNLIKELY (size > 0 && __MF_CACHE_MISS_P (value, size))) \
+    if (acc == __MF_CHECK_WRITE || ! __mf_opts.ignore_reads) \
+    __mf_check ((void *) (value), (size), acc, "(" context ")"); \
+ } while (0)
+#define BEGIN_PROTECT(fname, ...)       \
+  if (UNLIKELY (__mf_starting_p)) \
+  {                                         \
+    return CALL_BACKUP(fname, __VA_ARGS__); \
+  }                                         \
+  else if (UNLIKELY (__mf_get_state () == reentrant))   \
+  {                                         \
+    extern unsigned long __mf_reentrancy;   \
+    __mf_reentrancy ++; \
+    return CALL_REAL(fname, __VA_ARGS__);   \
+  }                                         \
+  else if (UNLIKELY (__mf_get_state () == in_malloc))   \
+  {                                         \
+    return CALL_REAL(fname, __VA_ARGS__);   \
+  }                                         \
+  else                                      \
+  {                                         \
+    TRACE ("%s\n", __PRETTY_FUNCTION__); \
+  }
+
+/* There is an assumption here that these will only be called in routines
+   that call BEGIN_PROTECT at the start, and hence the state must always
+   be active when BEGIN_MALLOC_PROTECT is called.  */
+#define BEGIN_MALLOC_PROTECT() \
+  __mf_set_state (in_malloc)
+
+#define END_MALLOC_PROTECT() \
+  __mf_set_state (active)
+
+/* Unlocked variants of main entry points from mf-runtime.h.  */
+extern void __mfu_check (void *ptr, size_t sz, int type, const char *location);
+extern void __mfu_register (void *ptr, size_t sz, int type, const char *name);
+extern void __mfu_unregister (void *ptr, size_t sz, int type);
+extern void __mfu_report ();
+extern int __mfu_set_options (const char *opts);
+
+
+#endif /* __MF_IMPL_H */

Added: llvm-gcc-4.2/trunk/libmudflap/mf-runtime.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/mf-runtime.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/mf-runtime.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/mf-runtime.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,2786 @@
+/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
+   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Contributed by Frank Ch. Eigler <fche at redhat.com>
+   and Graydon Hoare <graydon at redhat.com>
+   Splay Tree code originally by Mark Mitchell <mark at markmitchell.com>,
+   adapted from libiberty.
+
+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 2, or (at your option) any later
+version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+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 COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+#include "config.h"
+
+/* These attempt to coax various unix flavours to declare all our
+   needed tidbits in the system headers.  */
+#if !defined(__FreeBSD__) && !defined(__APPLE__)
+#define _POSIX_SOURCE
+#endif /* Some BSDs break <sys/socket.h> if this is defined. */
+#define _GNU_SOURCE
+#define _XOPEN_SOURCE
+#define _BSD_TYPES
+#define __EXTENSIONS__
+#define _ALL_SOURCE
+#define _LARGE_FILE_API
+#define _XOPEN_SOURCE_EXTENDED 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#ifdef HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#include <assert.h>
+
+#include <string.h>
+#include <limits.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include "mf-runtime.h"
+#include "mf-impl.h"
+
+
+/* ------------------------------------------------------------------------ */
+/* Splay-tree implementation.  */
+
+typedef uintptr_t mfsplay_tree_key;
+typedef void *mfsplay_tree_value;
+
+/* Forward declaration for a node in the tree.  */
+typedef struct mfsplay_tree_node_s *mfsplay_tree_node;
+
+/* The type of a function used to iterate over the tree.  */
+typedef int (*mfsplay_tree_foreach_fn) (mfsplay_tree_node, void *);
+
+/* The nodes in the splay tree.  */
+struct mfsplay_tree_node_s
+{
+  /* Data.  */
+  mfsplay_tree_key key;
+  mfsplay_tree_value value;
+  /* Children.  */
+  mfsplay_tree_node left;
+  mfsplay_tree_node right;
+  /* XXX: The addition of a parent pointer may eliminate some recursion.  */
+};
+
+/* The splay tree itself.  */
+struct mfsplay_tree_s
+{
+  /* The root of the tree.  */
+  mfsplay_tree_node root;
+
+  /* The last key value for which the tree has been splayed, but not
+     since modified.  */
+  mfsplay_tree_key last_splayed_key;
+  int last_splayed_key_p;
+
+  /* Statistics.  */
+  unsigned num_keys;
+
+  /* Traversal recursion control flags.  */
+  unsigned max_depth;
+  unsigned depth;
+  unsigned rebalance_p;
+};
+typedef struct mfsplay_tree_s *mfsplay_tree;
+
+static mfsplay_tree mfsplay_tree_new (void);
+static mfsplay_tree_node mfsplay_tree_insert (mfsplay_tree, mfsplay_tree_key, mfsplay_tree_value);
+static void mfsplay_tree_remove (mfsplay_tree, mfsplay_tree_key);
+static mfsplay_tree_node mfsplay_tree_lookup (mfsplay_tree, mfsplay_tree_key);
+static mfsplay_tree_node mfsplay_tree_predecessor (mfsplay_tree, mfsplay_tree_key);
+static mfsplay_tree_node mfsplay_tree_successor (mfsplay_tree, mfsplay_tree_key);
+static int mfsplay_tree_foreach (mfsplay_tree, mfsplay_tree_foreach_fn, void *);
+static void mfsplay_tree_rebalance (mfsplay_tree sp);
+
+/* ------------------------------------------------------------------------ */
+/* Utility macros */
+
+#define CTOR  __attribute__ ((constructor))
+#define DTOR  __attribute__ ((destructor))
+
+
+/* Codes to describe the context in which a violation occurs. */
+#define __MF_VIOL_UNKNOWN 0
+#define __MF_VIOL_READ 1
+#define __MF_VIOL_WRITE 2
+#define __MF_VIOL_REGISTER 3
+#define __MF_VIOL_UNREGISTER 4
+#define __MF_VIOL_WATCH 5
+
+/* Protect against recursive calls. */
+
+static void
+begin_recursion_protect1 (const char *pf)
+{
+  if (__mf_get_state () == reentrant)
+    {
+      write (2, "mf: erroneous reentrancy detected in `", 38);
+      write (2, pf, strlen(pf));
+      write (2, "'\n", 2); \
+      abort ();
+    }
+  __mf_set_state (reentrant);
+}
+
+#define BEGIN_RECURSION_PROTECT() \
+  begin_recursion_protect1 (__PRETTY_FUNCTION__)
+
+#define END_RECURSION_PROTECT() \
+  __mf_set_state (active)
+
+/* ------------------------------------------------------------------------ */
+/* Required globals.  */
+
+#define LOOKUP_CACHE_MASK_DFL 1023
+#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];
+uintptr_t __mf_lc_mask = LOOKUP_CACHE_MASK_DFL;
+unsigned char __mf_lc_shift = LOOKUP_CACHE_SHIFT_DFL;
+#define LOOKUP_CACHE_SIZE (__mf_lc_mask + 1)
+
+struct __mf_options __mf_opts;
+int __mf_starting_p = 1;
+
+#ifdef LIBMUDFLAPTH
+#ifdef HAVE_TLS
+__thread enum __mf_state_enum __mf_state_1 = reentrant;
+#endif
+#else
+enum __mf_state_enum __mf_state_1 = reentrant;
+#endif
+
+#ifdef LIBMUDFLAPTH
+pthread_mutex_t __mf_biglock =
+#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+       PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
+#else
+       PTHREAD_MUTEX_INITIALIZER;
+#endif
+#endif
+
+/* Use HAVE_PTHREAD_H here instead of LIBMUDFLAPTH, so that even
+   the libmudflap.la (no threading support) can diagnose whether
+   the application is linked with -lpthread.  See __mf_usage() below.  */
+#if HAVE_PTHREAD_H
+#ifdef _POSIX_THREADS
+#pragma weak pthread_join
+#else
+#define pthread_join NULL
+#endif
+#endif
+
+
+/* ------------------------------------------------------------------------ */
+/* stats-related globals.  */
+
+static unsigned long __mf_count_check;
+static unsigned long __mf_lookup_cache_reusecount [LOOKUP_CACHE_SIZE_MAX];
+static unsigned long __mf_count_register;
+static unsigned long __mf_total_register_size [__MF_TYPE_MAX+1];
+static unsigned long __mf_count_unregister;
+static unsigned long __mf_total_unregister_size;
+static unsigned long __mf_count_violation [__MF_VIOL_WATCH+1];
+static unsigned long __mf_sigusr1_received;
+static unsigned long __mf_sigusr1_handled;
+/* not static */ unsigned long __mf_reentrancy;
+#ifdef LIBMUDFLAPTH
+/* not static */ unsigned long __mf_lock_contention;
+#endif
+
+
+/* ------------------------------------------------------------------------ */
+/* mode-check-related globals.  */
+
+typedef struct __mf_object
+{
+  uintptr_t low, high; /* __mf_register parameters */
+  const char *name;
+  char type; /* __MF_TYPE_something */
+  char watching_p; /* Trigger a VIOL_WATCH on access? */
+  unsigned read_count; /* Number of times __mf_check/read was called on this object.  */
+  unsigned write_count; /* Likewise for __mf_check/write.  */
+  unsigned liveness; /* A measure of recent checking activity.  */
+  unsigned description_epoch; /* Last epoch __mf_describe_object printed this.  */
+
+  uintptr_t alloc_pc;
+  struct timeval alloc_time;
+  char **alloc_backtrace;
+  size_t alloc_backtrace_size;
+#ifdef LIBMUDFLAPTH
+  pthread_t alloc_thread;
+#endif
+
+  int deallocated_p;
+  uintptr_t dealloc_pc;
+  struct timeval dealloc_time;
+  char **dealloc_backtrace;
+  size_t dealloc_backtrace_size;
+#ifdef LIBMUDFLAPTH
+  pthread_t dealloc_thread;
+#endif
+} __mf_object_t;
+
+/* Live objects: splay trees, separated by type, ordered on .low (base address).  */
+/* Actually stored as static vars within lookup function below.  */
+
+/* Dead objects: circular arrays; _MIN_CEM .. _MAX_CEM only */
+static unsigned __mf_object_dead_head[__MF_TYPE_MAX_CEM+1]; /* next empty spot */
+static __mf_object_t *__mf_object_cemetary[__MF_TYPE_MAX_CEM+1][__MF_PERSIST_MAX];
+
+
+/* ------------------------------------------------------------------------ */
+/* Forward function declarations */
+
+void __mf_init () CTOR;
+static void __mf_sigusr1_respond ();
+static unsigned __mf_find_objects (uintptr_t ptr_low, uintptr_t ptr_high,
+                                   __mf_object_t **objs, unsigned max_objs);
+static unsigned __mf_find_objects2 (uintptr_t ptr_low, uintptr_t ptr_high,
+                                    __mf_object_t **objs, unsigned max_objs, int type);
+static unsigned __mf_find_dead_objects (uintptr_t ptr_low, uintptr_t ptr_high,
+                                        __mf_object_t **objs, unsigned max_objs);
+static void __mf_adapt_cache ();
+static void __mf_describe_object (__mf_object_t *obj);
+static unsigned __mf_watch_or_not (void *ptr, size_t sz, char flag);
+static mfsplay_tree __mf_object_tree (int type);
+static void __mf_link_object (__mf_object_t *node);
+static void __mf_unlink_object (__mf_object_t *node);
+
+
+/* ------------------------------------------------------------------------ */
+/* Configuration engine */
+
+static void
+__mf_set_default_options ()
+{
+  memset (& __mf_opts, 0, sizeof (__mf_opts));
+
+  __mf_opts.adapt_cache = 1000003;
+  __mf_opts.abbreviate = 1;
+  __mf_opts.verbose_violations = 1;
+  __mf_opts.free_queue_length = 4;
+  __mf_opts.persistent_count = 100;
+  __mf_opts.crumple_zone = 32;
+  __mf_opts.backtrace = 4;
+  __mf_opts.timestamps = 1;
+  __mf_opts.mudflap_mode = mode_check;
+  __mf_opts.violation_mode = viol_nop;
+  __mf_opts.heur_std_data = 1;
+#ifdef LIBMUDFLAPTH
+  __mf_opts.thread_stack = 0;
+#endif
+}
+
+static struct option
+{
+  char *name;
+  char *description;
+  enum
+    {
+      set_option,
+      read_integer_option,
+    } type;
+  unsigned value;
+  unsigned *target;
+}
+options [] =
+  {
+    {"mode-nop",
+     "mudflaps do nothing",
+     set_option, (unsigned)mode_nop, (unsigned *)&__mf_opts.mudflap_mode},
+    {"mode-populate",
+     "mudflaps populate object tree",
+     set_option, (unsigned)mode_populate, (unsigned *)&__mf_opts.mudflap_mode},
+    {"mode-check",
+     "mudflaps check for memory violations",
+     set_option, (unsigned)mode_check, (unsigned *)&__mf_opts.mudflap_mode},
+    {"mode-violate",
+     "mudflaps always cause violations (diagnostic)",
+     set_option, (unsigned)mode_violate, (unsigned *)&__mf_opts.mudflap_mode},
+
+    {"viol-nop",
+     "violations do not change program execution",
+     set_option, (unsigned)viol_nop, (unsigned *)&__mf_opts.violation_mode},
+    {"viol-abort",
+     "violations cause a call to abort()",
+     set_option, (unsigned)viol_abort, (unsigned *)&__mf_opts.violation_mode},
+    {"viol-segv",
+     "violations are promoted to SIGSEGV signals",
+     set_option, (unsigned)viol_segv, (unsigned *)&__mf_opts.violation_mode},
+    {"viol-gdb",
+     "violations fork a gdb process attached to current program",
+     set_option, (unsigned)viol_gdb, (unsigned *)&__mf_opts.violation_mode},
+    {"trace-calls",
+     "trace calls to mudflap runtime library",
+     set_option, 1, &__mf_opts.trace_mf_calls},
+    {"verbose-trace",
+     "trace internal events within mudflap runtime library",
+     set_option, 1, &__mf_opts.verbose_trace},
+    {"collect-stats",
+     "collect statistics on mudflap's operation",
+     set_option, 1, &__mf_opts.collect_stats},
+#ifdef SIGUSR1
+    {"sigusr1-report",
+     "print report upon SIGUSR1",
+     set_option, 1, &__mf_opts.sigusr1_report},
+#endif
+    {"internal-checking",
+     "perform more expensive internal checking",
+     set_option, 1, &__mf_opts.internal_checking},
+    {"print-leaks",
+     "print any memory leaks at program shutdown",
+     set_option, 1, &__mf_opts.print_leaks},
+    {"check-initialization",
+     "detect uninitialized object reads",
+     set_option, 1, &__mf_opts.check_initialization},
+    {"verbose-violations",
+     "print verbose messages when memory violations occur",
+     set_option, 1, &__mf_opts.verbose_violations},
+    {"abbreviate",
+     "abbreviate repetitive listings",
+     set_option, 1, &__mf_opts.abbreviate},
+    {"timestamps",
+     "track object lifetime timestamps",
+     set_option, 1, &__mf_opts.timestamps},
+    {"ignore-reads",
+     "ignore read accesses - assume okay",
+     set_option, 1, &__mf_opts.ignore_reads},
+    {"wipe-stack",
+     "wipe stack objects at unwind",
+     set_option, 1, &__mf_opts.wipe_stack},
+    {"wipe-heap",
+     "wipe heap objects at free",
+     set_option, 1, &__mf_opts.wipe_heap},
+    {"heur-proc-map",
+     "support /proc/self/map heuristics",
+     set_option, 1, &__mf_opts.heur_proc_map},
+    {"heur-stack-bound",
+     "enable a simple upper stack bound heuristic",
+     set_option, 1, &__mf_opts.heur_stack_bound},
+    {"heur-start-end",
+     "support _start.._end heuristics",
+     set_option, 1, &__mf_opts.heur_start_end},
+    {"heur-stdlib",
+     "register standard library data (argv, errno, stdin, ...)",
+     set_option, 1, &__mf_opts.heur_std_data},
+    {"free-queue-length",
+     "queue N deferred free() calls before performing them",
+     read_integer_option, 0, &__mf_opts.free_queue_length},
+    {"persistent-count",
+     "keep a history of N unregistered regions",
+     read_integer_option, 0, &__mf_opts.persistent_count},
+    {"crumple-zone",
+     "surround allocations with crumple zones of N bytes",
+     read_integer_option, 0, &__mf_opts.crumple_zone},
+    /* XXX: not type-safe.
+    {"lc-mask",
+     "set lookup cache size mask to N (2**M - 1)",
+     read_integer_option, 0, (int *)(&__mf_lc_mask)},
+    {"lc-shift",
+     "set lookup cache pointer shift",
+     read_integer_option, 0, (int *)(&__mf_lc_shift)},
+    */
+    {"lc-adapt",
+     "adapt mask/shift parameters after N cache misses",
+     read_integer_option, 1, &__mf_opts.adapt_cache},
+    {"backtrace",
+     "keep an N-level stack trace of each call context",
+     read_integer_option, 0, &__mf_opts.backtrace},
+#ifdef LIBMUDFLAPTH
+    {"thread-stack",
+     "override thread stacks allocation: N kB",
+     read_integer_option, 0, &__mf_opts.thread_stack},
+#endif
+    {0, 0, set_option, 0, NULL}
+  };
+
+static void
+__mf_usage ()
+{
+  struct option *opt;
+
+  fprintf (stderr,
+           "This is a %s%sGCC \"mudflap\" memory-checked binary.\n"
+           "Mudflap is Copyright (C) 2002-2004 Free Software Foundation, Inc.\n"
+           "\n"
+           "The mudflap code can be controlled by an environment variable:\n"
+           "\n"
+           "$ export MUDFLAP_OPTIONS='<options>'\n"
+           "$ <mudflapped_program>\n"
+           "\n"
+           "where <options> is a space-separated list of \n"
+           "any of the following options.  Use `-no-OPTION' to disable options.\n"
+           "\n",
+#if HAVE_PTHREAD_H
+           (pthread_join ? "multi-threaded " : "single-threaded "),
+#else
+           "",
+#endif
+#if LIBMUDFLAPTH
+           "thread-aware "
+#else
+           "thread-unaware "
+#endif
+            );
+  /* XXX: The multi-threaded thread-unaware combination is bad.  */
+
+  for (opt = options; opt->name; opt++)
+    {
+      int default_p = (opt->value == * opt->target);
+
+      switch (opt->type)
+        {
+          char buf[128];
+        case set_option:
+          fprintf (stderr, "-%-23.23s %s", opt->name, opt->description);
+          if (default_p)
+            fprintf (stderr, " [active]\n");
+          else
+            fprintf (stderr, "\n");
+          break;
+        case read_integer_option:
+          strncpy (buf, opt->name, 128);
+          strncpy (buf + strlen (opt->name), "=N", 2);
+          fprintf (stderr, "-%-23.23s %s", buf, opt->description);
+          fprintf (stderr, " [%d]\n", * opt->target);
+          break;
+        default: abort();
+        }
+    }
+
+  fprintf (stderr, "\n");
+}
+
+
+int
+__mf_set_options (const char *optstr)
+{
+  int rc;
+  LOCKTH ();
+  BEGIN_RECURSION_PROTECT ();
+  rc = __mfu_set_options (optstr);
+  /* XXX: It's not really that easy.  A change to a bunch of parameters
+     can require updating auxiliary state or risk crashing:
+     free_queue_length, crumple_zone ... */
+  END_RECURSION_PROTECT ();
+  UNLOCKTH ();
+  return rc;
+}
+
+
+int
+__mfu_set_options (const char *optstr)
+{
+  struct option *opts = 0;
+  char *nxt = 0;
+  long tmp = 0;
+  int rc = 0;
+  const char *saved_optstr = optstr;
+
+  /* XXX: bounds-check for optstr! */
+
+  while (*optstr)
+    {
+      switch (*optstr) {
+      case ' ':
+      case '\t':
+      case '\n':
+        optstr++;
+        break;
+
+      case '-':
+        if (*optstr+1)
+          {
+            int negate = 0;
+            optstr++;
+
+            if (*optstr == '?' ||
+                strncmp (optstr, "help", 4) == 0)
+              {
+                /* Caller will print help and exit.  */
+                return -1;
+              }
+
+            if (strncmp (optstr, "no-", 3) == 0)
+              {
+                negate = 1;
+                optstr = & optstr[3];
+              }
+
+            for (opts = options; opts->name; opts++)
+              {
+                if (strncmp (optstr, opts->name, strlen (opts->name)) == 0)
+                  {
+                    optstr += strlen (opts->name);
+                    assert (opts->target);
+                    switch (opts->type)
+                      {
+                      case set_option:
+                        if (negate)
+                          *(opts->target) = 0;
+                        else
+                          *(opts->target) = opts->value;
+                        break;
+                      case read_integer_option:
+                        if (! negate && (*optstr == '=' && *(optstr+1)))
+                          {
+                            optstr++;
+                            tmp = strtol (optstr, &nxt, 10);
+                            if ((optstr != nxt) && (tmp != LONG_MAX))
+                              {
+                                optstr = nxt;
+                                *(opts->target) = (int)tmp;
+                              }
+                          }
+                        else if (negate)
+                          * opts->target = 0;
+                        break;
+                      }
+                  }
+              }
+          }
+        break;
+
+      default:
+        fprintf (stderr,
+                 "warning: unrecognized string '%s' in mudflap options\n",
+                 optstr);
+        optstr += strlen (optstr);
+        rc = -1;
+        break;
+      }
+    }
+
+  /* Special post-processing: bound __mf_lc_mask and free_queue_length for security. */
+  __mf_lc_mask &= (LOOKUP_CACHE_SIZE_MAX - 1);
+  __mf_opts.free_queue_length &= (__MF_FREEQ_MAX - 1);
+
+  /* Clear the lookup cache, in case the parameters got changed.  */
+  /* XXX: race */
+  memset (__mf_lookup_cache, 0, sizeof(__mf_lookup_cache));
+  /* void slot 0 */
+  __mf_lookup_cache[0].low = MAXPTR;
+
+  TRACE ("set options from `%s'\n", saved_optstr);
+
+  /* Call this unconditionally, in case -sigusr1-report was toggled. */
+  __mf_sigusr1_respond ();
+
+  return rc;
+}
+
+
+#ifdef PIC
+
+void
+__mf_resolve_single_dynamic (struct __mf_dynamic_entry *e)
+{
+  char *err;
+
+  assert (e);
+  if (e->pointer) return;
+
+#if HAVE_DLVSYM
+  if (e->version != NULL && e->version[0] != '\0') /* non-null/empty */
+    e->pointer = dlvsym (RTLD_NEXT, e->name, e->version);
+  else
+#endif
+    e->pointer = dlsym (RTLD_NEXT, e->name);
+
+  err = dlerror ();
+
+  if (err)
+    {
+      fprintf (stderr, "mf: error in dlsym(\"%s\"): %s\n",
+               e->name, err);
+      abort ();
+    }
+  if (! e->pointer)
+    {
+      fprintf (stderr, "mf: dlsym(\"%s\") = NULL\n", e->name);
+      abort ();
+    }
+}
+
+
+static void
+__mf_resolve_dynamics ()
+{
+  int i;
+  for (i = 0; i < dyn_INITRESOLVE; i++)
+    __mf_resolve_single_dynamic (& __mf_dynamic[i]);
+}
+
+
+/* NB: order must match enums in mf-impl.h */
+struct __mf_dynamic_entry __mf_dynamic [] =
+{
+  {NULL, "calloc", NULL},
+  {NULL, "free", NULL},
+  {NULL, "malloc", NULL},
+  {NULL, "mmap", NULL},
+  {NULL, "munmap", NULL},
+  {NULL, "realloc", NULL},
+  {NULL, "DUMMY", NULL}, /* dyn_INITRESOLVE */
+#ifdef LIBMUDFLAPTH
+  {NULL, "pthread_create", PTHREAD_CREATE_VERSION},
+  {NULL, "pthread_join", NULL},
+  {NULL, "pthread_exit", NULL}
+#endif
+};
+
+#endif /* PIC */
+
+
+
+/* ------------------------------------------------------------------------ */
+
+/* Lookup & manage automatic initialization of the five or so splay trees.  */
+static mfsplay_tree
+__mf_object_tree (int type)
+{
+  static mfsplay_tree trees [__MF_TYPE_MAX+1];
+  assert (type >= 0 && type <= __MF_TYPE_MAX);
+  if (UNLIKELY (trees[type] == NULL))
+    trees[type] = mfsplay_tree_new ();
+  return trees[type];
+}
+
+
+/* not static */void
+__mf_init ()
+{
+  char *ov = 0;
+
+  /* Return if initialization has already been done. */
+  if (LIKELY (__mf_starting_p == 0))
+    return;
+
+  /* This initial bootstrap phase requires that __mf_starting_p = 1. */
+#ifdef PIC
+  __mf_resolve_dynamics ();
+#endif
+  __mf_starting_p = 0;
+
+  __mf_set_state (active);
+
+  __mf_set_default_options ();
+
+  ov = getenv ("MUDFLAP_OPTIONS");
+  if (ov)
+    {
+      int rc = __mfu_set_options (ov);
+      if (rc < 0)
+        {
+          __mf_usage ();
+          exit (1);
+        }
+    }
+
+  /* Initialize to a non-zero description epoch. */
+  __mf_describe_object (NULL);
+
+#define REG_RESERVED(obj) \
+  __mf_register (& obj, sizeof(obj), __MF_TYPE_NOACCESS, # obj)
+
+  REG_RESERVED (__mf_lookup_cache);
+  REG_RESERVED (__mf_lc_mask);
+  REG_RESERVED (__mf_lc_shift);
+  /* XXX: others of our statics?  */
+
+  /* Prevent access to *NULL. */
+  __mf_register (MINPTR, 1, __MF_TYPE_NOACCESS, "NULL");
+  __mf_lookup_cache[0].low = (uintptr_t) -1;
+}
+
+
+
+int
+__wrap_main (int argc, char* argv[])
+{
+  extern char **environ;
+  extern int main ();
+  extern int __real_main ();
+  static int been_here = 0;
+
+  if (__mf_opts.heur_std_data && ! been_here)
+    {
+      unsigned i;
+
+      been_here = 1;
+      __mf_register (argv, sizeof(char *)*(argc+1), __MF_TYPE_STATIC, "argv[]");
+      for (i=0; i<argc; i++)
+        {
+          unsigned j = strlen (argv[i]);
+          __mf_register (argv[i], j+1, __MF_TYPE_STATIC, "argv element");
+        }
+
+      for (i=0; ; i++)
+        {
+          char *e = environ[i];
+          unsigned j;
+          if (e == NULL) break;
+          j = strlen (environ[i]);
+          __mf_register (environ[i], j+1, __MF_TYPE_STATIC, "environ element");
+        }
+      __mf_register (environ, sizeof(char *)*(i+1), __MF_TYPE_STATIC, "environ[]");
+
+      __mf_register (& errno, sizeof (errno), __MF_TYPE_STATIC, "errno area");
+
+      __mf_register (stdin,  sizeof (*stdin),  __MF_TYPE_STATIC, "stdin");
+      __mf_register (stdout, sizeof (*stdout), __MF_TYPE_STATIC, "stdout");
+      __mf_register (stderr, sizeof (*stderr), __MF_TYPE_STATIC, "stderr");
+
+      /* Make some effort to register ctype.h static arrays.  */
+      /* XXX: e.g., on Solaris, may need to register __ctype, _ctype, __ctype_mask, __toupper, etc. */
+      /* On modern Linux GLIBC, these are thread-specific and changeable, and are dealt
+         with in mf-hooks2.c.  */
+    }
+
+#ifdef PIC
+  return main (argc, argv, environ);
+#else
+  return __real_main (argc, argv, environ);
+#endif
+}
+
+
+
+extern void __mf_fini () DTOR;
+void __mf_fini ()
+{
+  TRACE ("__mf_fini\n");
+  __mfu_report ();
+
+#ifndef PIC
+/* Since we didn't populate the tree for allocations in constructors
+   before __mf_init, we cannot check destructors after __mf_fini.  */
+  __mf_opts.mudflap_mode = mode_nop;
+#endif
+}
+
+
+
+/* ------------------------------------------------------------------------ */
+/* __mf_check */
+
+void __mf_check (void *ptr, size_t sz, int type, const char *location)
+{
+  LOCKTH ();
+  BEGIN_RECURSION_PROTECT ();
+  __mfu_check (ptr, sz, type, location);
+  END_RECURSION_PROTECT ();
+  UNLOCKTH ();
+}
+
+
+void __mfu_check (void *ptr, size_t sz, int type, const char *location)
+{
+  unsigned entry_idx = __MF_CACHE_INDEX (ptr);
+  struct __mf_cache *entry = & __mf_lookup_cache [entry_idx];
+  int judgement = 0; /* 0=undecided; <0=violation; >0=okay */
+  uintptr_t ptr_low = (uintptr_t) ptr;
+  uintptr_t ptr_high = CLAMPSZ (ptr, sz);
+  struct __mf_cache old_entry = *entry;
+
+  if (UNLIKELY (__mf_opts.sigusr1_report))
+    __mf_sigusr1_respond ();
+  if (UNLIKELY (__mf_opts.ignore_reads && type == 0))
+    return;
+
+  TRACE ("check ptr=%p b=%u size=%lu %s location=`%s'\n",
+         ptr, entry_idx, (unsigned long)sz,
+         (type == 0 ? "read" : "write"), location);
+
+  switch (__mf_opts.mudflap_mode)
+    {
+    case mode_nop:
+      /* It is tempting to poison the cache here similarly to
+         mode_populate.  However that eliminates a valuable
+         distinction between these two modes.  mode_nop is useful to
+         let a user count & trace every single check / registration
+         call.  mode_populate is useful to let a program run fast
+         while unchecked.
+      */
+      judgement = 1;
+      break;
+
+    case mode_populate:
+      entry->low = ptr_low;
+      entry->high = ptr_high;
+      judgement = 1;
+      break;
+
+    case mode_check:
+      {
+        unsigned heuristics = 0;
+
+        /* Advance aging/adaptation counters.  */
+        static unsigned adapt_count;
+        adapt_count ++;
+        if (UNLIKELY (__mf_opts.adapt_cache > 0 &&
+                      adapt_count > __mf_opts.adapt_cache))
+          {
+            adapt_count = 0;
+            __mf_adapt_cache ();
+          }
+
+        /* Looping only occurs if heuristics were triggered.  */
+        while (judgement == 0)
+          {
+            DECLARE (void, free, void *p);
+            __mf_object_t* ovr_obj[1];
+            unsigned obj_count;
+            __mf_object_t** all_ovr_obj = NULL;
+            __mf_object_t** dealloc_me = NULL;
+            unsigned i;
+
+            /* Find all overlapping objects.  Be optimistic that there is just one.  */
+            obj_count = __mf_find_objects (ptr_low, ptr_high, ovr_obj, 1);
+            if (UNLIKELY (obj_count > 1))
+              {
+                /* Allocate a real buffer and do the search again.  */
+                DECLARE (void *, malloc, size_t c);
+                unsigned n;
+                all_ovr_obj = CALL_REAL (malloc, (sizeof (__mf_object_t *) *
+                                                   obj_count));
+                if (all_ovr_obj == NULL) abort ();
+                n = __mf_find_objects (ptr_low, ptr_high, all_ovr_obj, obj_count);
+                assert (n == obj_count);
+                dealloc_me = all_ovr_obj;
+              }
+            else
+              {
+                all_ovr_obj = ovr_obj;
+                dealloc_me = NULL;
+              }
+
+            /* Update object statistics.  */
+            for (i = 0; i < obj_count; i++)
+              {
+                __mf_object_t *obj = all_ovr_obj[i];
+                assert (obj != NULL);
+                if (type == __MF_CHECK_READ)
+                  obj->read_count ++;
+                else
+                  obj->write_count ++;
+                obj->liveness ++;
+              }
+
+            /* Iterate over the various objects.  There are a number of special cases.  */
+            for (i = 0; i < obj_count; i++)
+              {
+                  __mf_object_t *obj = all_ovr_obj[i];
+
+                /* Any __MF_TYPE_NOACCESS hit is bad.  */
+                if (UNLIKELY (obj->type == __MF_TYPE_NOACCESS))
+                  judgement = -1;
+
+                /* Any object with a watch flag is bad.  */
+                if (UNLIKELY (obj->watching_p))
+                  judgement = -2; /* trigger VIOL_WATCH */
+
+                /* A read from an uninitialized object is bad. */
+                if (UNLIKELY (__mf_opts.check_initialization
+                              /* reading */
+                              && type == __MF_CHECK_READ
+                              /* not written */
+                              && obj->write_count == 0
+                              /* uninitialized (heap) */
+                              && obj->type == __MF_TYPE_HEAP))
+                  judgement = -1;
+              }
+
+            /* We now know that the access spans no invalid objects.  */
+            if (LIKELY (judgement >= 0))
+              for (i = 0; i < obj_count; i++)
+                {
+                  __mf_object_t *obj = all_ovr_obj[i];
+
+                  /* Is this access entirely contained within this object?  */
+                  if (LIKELY (ptr_low >= obj->low && ptr_high <= obj->high))
+                    {
+                      /* Valid access.  */
+                      entry->low = obj->low;
+                      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];
+
+                        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);
+
+            /* If the judgment is still unknown at this stage, loop
+               around at most one more time.  */
+            if (judgement == 0)
+              {
+                if (heuristics++ < 2) /* XXX parametrize this number? */
+                  judgement = __mf_heuristic_check (ptr_low, ptr_high);
+                else
+                  judgement = -1;
+              }
+          }
+
+      }
+      break;
+
+    case mode_violate:
+      judgement = -1;
+      break;
+    }
+
+  if (__mf_opts.collect_stats)
+    {
+      __mf_count_check ++;
+
+      if (LIKELY (old_entry.low != entry->low || old_entry.high != entry->high))
+        /* && (old_entry.low != 0) && (old_entry.high != 0)) */
+        __mf_lookup_cache_reusecount [entry_idx] ++;
+    }
+
+  if (UNLIKELY (judgement < 0))
+    __mf_violation (ptr, sz,
+                    (uintptr_t) __builtin_return_address (0), location,
+                    ((judgement == -1) ?
+                     (type == __MF_CHECK_READ ? __MF_VIOL_READ : __MF_VIOL_WRITE) :
+                     __MF_VIOL_WATCH));
+}
+
+
+static __mf_object_t *
+__mf_insert_new_object (uintptr_t low, uintptr_t high, int type,
+                        const char *name, uintptr_t pc)
+{
+  DECLARE (void *, calloc, size_t c, size_t n);
+
+  __mf_object_t *new_obj;
+  new_obj = CALL_REAL (calloc, 1, sizeof(__mf_object_t));
+  new_obj->low = low;
+  new_obj->high = high;
+  new_obj->type = type;
+  new_obj->name = name;
+  new_obj->alloc_pc = pc;
+#if HAVE_GETTIMEOFDAY
+  if (__mf_opts.timestamps)
+    gettimeofday (& new_obj->alloc_time, NULL);
+#endif
+#if LIBMUDFLAPTH
+  new_obj->alloc_thread = pthread_self ();
+#endif
+
+  if (__mf_opts.backtrace > 0 && (type == __MF_TYPE_HEAP || type == __MF_TYPE_HEAP_I))
+    new_obj->alloc_backtrace_size =
+      __mf_backtrace (& new_obj->alloc_backtrace,
+                      (void *) pc, 2);
+
+  __mf_link_object (new_obj);
+  return new_obj;
+}
+
+
+static void
+__mf_uncache_object (__mf_object_t *old_obj)
+{
+  /* Remove any low/high pointers for this object from the lookup cache.  */
+
+  /* Can it possibly exist in the cache?  */
+  if (LIKELY (old_obj->read_count + old_obj->write_count))
+    {
+      /* As reported by Herman ten Brugge, we need to scan the entire
+         cache for entries that may hit this object. */
+      uintptr_t low = old_obj->low;
+      uintptr_t high = old_obj->high;
+      struct __mf_cache *entry = & __mf_lookup_cache [0];
+      unsigned i;
+      for (i = 0; i <= __mf_lc_mask; i++, entry++)
+        {
+          /* NB: the "||" in the following test permits this code to
+             tolerate the situation introduced by __mf_check over
+             contiguous objects, where a cache entry spans several
+             objects.  */
+          if (entry->low == low || entry->high == high)
+            {
+              entry->low = MAXPTR;
+              entry->high = MINPTR;
+            }
+        }
+    }
+}
+
+
+void
+__mf_register (void *ptr, size_t sz, int type, const char *name)
+{
+  LOCKTH ();
+  BEGIN_RECURSION_PROTECT ();
+  __mfu_register (ptr, sz, type, name);
+  END_RECURSION_PROTECT ();
+  UNLOCKTH ();
+}
+
+
+void
+__mfu_register (void *ptr, size_t sz, int type, const char *name)
+{
+  TRACE ("register ptr=%p size=%lu type=%x name='%s'\n",
+         ptr, (unsigned long) sz, type, name ? name : "");
+
+  if (__mf_opts.collect_stats)
+    {
+      __mf_count_register ++;
+      __mf_total_register_size [(type < 0) ? 0 :
+                                (type > __MF_TYPE_MAX) ? 0 :
+                                type] += sz;
+    }
+
+  if (UNLIKELY (__mf_opts.sigusr1_report))
+    __mf_sigusr1_respond ();
+
+  switch (__mf_opts.mudflap_mode)
+    {
+    case mode_nop:
+      break;
+
+    case mode_violate:
+      __mf_violation (ptr, sz, (uintptr_t) __builtin_return_address (0), NULL,
+                      __MF_VIOL_REGISTER);
+      break;
+
+    case mode_populate:
+      /* Clear the cache.  */
+      /* XXX: why the entire cache? */
+      /* XXX: race */
+      memset (__mf_lookup_cache, 0, sizeof(__mf_lookup_cache));
+      /* void slot 0 */
+      __mf_lookup_cache[0].low = MAXPTR;
+      break;
+
+    case mode_check:
+      {
+        __mf_object_t *ovr_objs [1];
+        unsigned num_overlapping_objs;
+        uintptr_t low = (uintptr_t) ptr;
+        uintptr_t high = CLAMPSZ (ptr, sz);
+        uintptr_t pc = (uintptr_t) __builtin_return_address (0);
+
+        /* Treat unknown size indication as 1.  */
+        if (UNLIKELY (sz == 0)) sz = 1;
+
+        /* Look for objects only of the same type.  This will e.g. permit a registration
+           of a STATIC overlapping with a GUESS, and a HEAP with a NOACCESS.  At
+           __mf_check time however harmful overlaps will be detected. */
+        num_overlapping_objs = __mf_find_objects2 (low, high, ovr_objs, 1, type);
+
+        /* Handle overlaps.  */
+        if (UNLIKELY (num_overlapping_objs > 0))
+          {
+            __mf_object_t *ovr_obj = ovr_objs[0];
+
+            /* Accept certain specific duplication pairs.  */
+            if (((type == __MF_TYPE_STATIC) || (type == __MF_TYPE_GUESS))
+                && ovr_obj->low == low
+                && ovr_obj->high == high
+                && ovr_obj->type == type)
+              {
+                /* Duplicate registration for static objects may come
+                   from distinct compilation units.  */
+                VERBOSE_TRACE ("harmless duplicate reg %p-%p `%s'\n",
+                               (void *) low, (void *) high,
+                               (ovr_obj->name ? ovr_obj->name : ""));
+                break;
+              }
+
+            /* Alas, a genuine violation.  */
+            else
+              {
+                /* Two or more *real* mappings here. */
+                __mf_violation ((void *) ptr, sz,
+                                (uintptr_t) __builtin_return_address (0), NULL,
+                                __MF_VIOL_REGISTER);
+              }
+          }
+        else /* No overlapping objects: AOK.  */
+          __mf_insert_new_object (low, high, type, name, pc);
+
+        /* We could conceivably call __mf_check() here to prime the cache,
+           but then the read_count/write_count field is not reliable.  */
+        break;
+      }
+    } /* end switch (__mf_opts.mudflap_mode) */
+}
+
+
+void
+__mf_unregister (void *ptr, size_t sz, int type)
+{
+  LOCKTH ();
+  BEGIN_RECURSION_PROTECT ();
+  __mfu_unregister (ptr, sz, type);
+  END_RECURSION_PROTECT ();
+  UNLOCKTH ();
+}
+
+
+void
+__mfu_unregister (void *ptr, size_t sz, int type)
+{
+  DECLARE (void, free, void *ptr);
+
+  if (UNLIKELY (__mf_opts.sigusr1_report))
+    __mf_sigusr1_respond ();
+
+  TRACE ("unregister ptr=%p size=%lu type=%x\n", ptr, (unsigned long) sz, type);
+
+  switch (__mf_opts.mudflap_mode)
+    {
+    case mode_nop:
+      break;
+
+    case mode_violate:
+      __mf_violation (ptr, sz,
+                      (uintptr_t) __builtin_return_address (0), NULL,
+                      __MF_VIOL_UNREGISTER);
+      break;
+
+    case mode_populate:
+      /* Clear the cache.  */
+      /* XXX: race */
+      memset (__mf_lookup_cache, 0, sizeof(__mf_lookup_cache));
+      /* void slot 0 */
+      __mf_lookup_cache[0].low = MAXPTR;
+      break;
+
+    case mode_check:
+      {
+        __mf_object_t *old_obj = NULL;
+        __mf_object_t *del_obj = NULL;  /* Object to actually delete. */
+        __mf_object_t *objs[1] = {NULL};
+        unsigned num_overlapping_objs;
+
+        num_overlapping_objs = __mf_find_objects2 ((uintptr_t) ptr,
+                                                   CLAMPSZ (ptr, sz), objs, 1, type);
+
+        /* Special case for HEAP_I - see free & realloc hook.  They don't
+           know whether the input region was HEAP or HEAP_I before
+           unmapping it.  Here we give HEAP a try in case HEAP_I
+           failed.  */
+        if ((type == __MF_TYPE_HEAP_I) && (num_overlapping_objs == 0))
+          {
+            num_overlapping_objs = __mf_find_objects2 ((uintptr_t) ptr,
+                                                       CLAMPSZ (ptr, sz), objs, 1, __MF_TYPE_HEAP);
+          }
+
+        old_obj = objs[0];
+        if (UNLIKELY ((num_overlapping_objs != 1) /* more than one overlap */
+                      || ((sz == 0) ? 0 : (sz != (old_obj->high - old_obj->low + 1))) /* size mismatch */
+                      || ((uintptr_t) ptr != old_obj->low))) /* base mismatch */
+          {
+            __mf_violation (ptr, sz,
+                            (uintptr_t) __builtin_return_address (0), NULL,
+                            __MF_VIOL_UNREGISTER);
+            break;
+          }
+
+        __mf_unlink_object (old_obj);
+        __mf_uncache_object (old_obj);
+
+        /* Wipe buffer contents if desired.  */
+        if ((__mf_opts.wipe_stack && old_obj->type == __MF_TYPE_STACK)
+            || (__mf_opts.wipe_heap && (old_obj->type == __MF_TYPE_HEAP
+                                        || old_obj->type == __MF_TYPE_HEAP_I)))
+          {
+            memset ((void *) old_obj->low,
+                    0,
+                    (size_t) (old_obj->high - old_obj->low + 1));
+          }
+
+        /* Manage the object cemetary.  */
+        if (__mf_opts.persistent_count > 0
+	    && (unsigned) old_obj->type <= __MF_TYPE_MAX_CEM)
+          {
+            old_obj->deallocated_p = 1;
+            old_obj->dealloc_pc = (uintptr_t) __builtin_return_address (0);
+#if HAVE_GETTIMEOFDAY
+            if (__mf_opts.timestamps)
+              gettimeofday (& old_obj->dealloc_time, NULL);
+#endif
+#ifdef LIBMUDFLAPTH
+            old_obj->dealloc_thread = pthread_self ();
+#endif
+
+            if (__mf_opts.backtrace > 0 && old_obj->type == __MF_TYPE_HEAP)
+              old_obj->dealloc_backtrace_size =
+                __mf_backtrace (& old_obj->dealloc_backtrace,
+                                NULL, 2);
+
+            /* Encourage this object to be displayed again in current epoch.  */
+            old_obj->description_epoch --;
+
+            /* Put this object into the cemetary.  This may require this plot to
+               be recycled, and the previous resident to be designated del_obj.  */
+            {
+              unsigned row = old_obj->type;
+              unsigned plot = __mf_object_dead_head [row];
+
+              del_obj = __mf_object_cemetary [row][plot];
+              __mf_object_cemetary [row][plot] = old_obj;
+              plot ++;
+              if (plot == __mf_opts.persistent_count) plot = 0;
+              __mf_object_dead_head [row] = plot;
+            }
+          }
+        else
+          del_obj = old_obj;
+
+        if (__mf_opts.print_leaks)
+          {
+            if ((old_obj->read_count + old_obj->write_count) == 0 &&
+                (old_obj->type == __MF_TYPE_HEAP
+                 || old_obj->type == __MF_TYPE_HEAP_I))
+              {
+                fprintf (stderr,
+                         "*******\n"
+                         "mudflap warning: unaccessed registered object:\n");
+                __mf_describe_object (old_obj);
+              }
+          }
+
+        if (del_obj != NULL) /* May or may not equal old_obj.  */
+          {
+            if (__mf_opts.backtrace > 0)
+              {
+                CALL_REAL(free, del_obj->alloc_backtrace);
+                if (__mf_opts.persistent_count > 0)
+                  {
+                    CALL_REAL(free, del_obj->dealloc_backtrace);
+                  }
+              }
+            CALL_REAL(free, del_obj);
+          }
+
+        break;
+      }
+    } /* end switch (__mf_opts.mudflap_mode) */
+
+
+  if (__mf_opts.collect_stats)
+    {
+      __mf_count_unregister ++;
+      __mf_total_unregister_size += sz;
+    }
+}
+
+
+
+struct tree_stats
+{
+  unsigned obj_count;
+  unsigned long total_size;
+  unsigned live_obj_count;
+  double total_weight;
+  double weighted_size;
+  unsigned long weighted_address_bits [sizeof (uintptr_t) * 8][2];
+};
+
+
+
+static int
+__mf_adapt_cache_fn (mfsplay_tree_node n, void *param)
+{
+  __mf_object_t *obj = (__mf_object_t *) n->value;
+  struct tree_stats *s = (struct tree_stats *) param;
+
+  assert (obj != NULL && s != NULL);
+
+  /* Exclude never-accessed objects.  */
+  if (obj->read_count + obj->write_count)
+    {
+      s->obj_count ++;
+      s->total_size += (obj->high - obj->low + 1);
+
+      if (obj->liveness)
+        {
+          unsigned i;
+          uintptr_t addr;
+
+          /* VERBOSE_TRACE ("analyze low=%p live=%u name=`%s'\n",
+             (void *) obj->low, obj->liveness, obj->name); */
+
+          s->live_obj_count ++;
+          s->total_weight += (double) obj->liveness;
+          s->weighted_size +=
+            (double) (obj->high - obj->low + 1) *
+            (double) obj->liveness;
+
+          addr = obj->low;
+          for (i=0; i<sizeof(uintptr_t) * 8; i++)
+            {
+              unsigned bit = addr & 1;
+              s->weighted_address_bits[i][bit] += obj->liveness;
+              addr = addr >> 1;
+            }
+
+          /* Age the liveness value.  */
+          obj->liveness >>= 1;
+        }
+    }
+
+  return 0;
+}
+
+
+static void
+__mf_adapt_cache ()
+{
+  struct tree_stats s;
+  uintptr_t new_mask = 0;
+  unsigned char new_shift;
+  float cache_utilization;
+  float max_value;
+  static float smoothed_new_shift = -1.0;
+  unsigned i;
+
+  memset (&s, 0, sizeof (s));
+
+  mfsplay_tree_foreach (__mf_object_tree (__MF_TYPE_HEAP), __mf_adapt_cache_fn, (void *) & s);
+  mfsplay_tree_foreach (__mf_object_tree (__MF_TYPE_HEAP_I), __mf_adapt_cache_fn, (void *) & s);
+  mfsplay_tree_foreach (__mf_object_tree (__MF_TYPE_STACK), __mf_adapt_cache_fn, (void *) & s);
+  mfsplay_tree_foreach (__mf_object_tree (__MF_TYPE_STATIC), __mf_adapt_cache_fn, (void *) & s);
+  mfsplay_tree_foreach (__mf_object_tree (__MF_TYPE_GUESS), __mf_adapt_cache_fn, (void *) & s);
+
+  /* Maybe we're dealing with funny aging/adaptation parameters, or an
+     empty tree.  Just leave the cache alone in such cases, rather
+     than risk dying by division-by-zero.  */
+  if (! (s.obj_count > 0) && (s.live_obj_count > 0) && (s.total_weight > 0.0))
+    return;
+
+  /* Guess a good value for the shift parameter by finding an address bit that is a
+     good discriminant of lively objects.  */
+  max_value = 0.0;
+  for (i=0; i<sizeof (uintptr_t)*8; i++)
+    {
+      float value = (float) s.weighted_address_bits[i][0] * (float) s.weighted_address_bits[i][1];
+      if (max_value < value) max_value = value;
+    }
+  for (i=0; i<sizeof (uintptr_t)*8; i++)
+    {
+      float shoulder_factor = 0.7;  /* Include slightly less popular bits too.  */
+      float value = (float) s.weighted_address_bits[i][0] * (float) s.weighted_address_bits[i][1];
+      if (value >= max_value * shoulder_factor)
+        break;
+    }
+  if (smoothed_new_shift < 0) smoothed_new_shift = __mf_lc_shift;
+  /* Converge toward this slowly to reduce flapping. */
+  smoothed_new_shift = 0.9*smoothed_new_shift + 0.1*i;
+  new_shift = (unsigned) (smoothed_new_shift + 0.5);
+  assert (new_shift < sizeof (uintptr_t)*8);
+
+  /* Count number of used buckets.  */
+  cache_utilization = 0.0;
+  for (i = 0; i < (1 + __mf_lc_mask); i++)
+    if (__mf_lookup_cache[i].low != 0 || __mf_lookup_cache[i].high != 0)
+      cache_utilization += 1.0;
+  cache_utilization /= (1 + __mf_lc_mask);
+
+  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 => "
+                 "util=%u%% m=%p s=%u\n",
+                 s.obj_count, s.live_obj_count, s.total_size, s.total_weight, s.weighted_size,
+                 (unsigned)(cache_utilization*100.0), (void *) new_mask, new_shift);
+
+  /* We should reinitialize cache if its parameters have changed.  */
+  if (new_mask != __mf_lc_mask ||
+      new_shift != __mf_lc_shift)
+    {
+      __mf_lc_mask = new_mask;
+      __mf_lc_shift = new_shift;
+      /* XXX: race */
+      memset (__mf_lookup_cache, 0, sizeof(__mf_lookup_cache));
+      /* void slot 0 */
+      __mf_lookup_cache[0].low = MAXPTR;
+    }
+}
+
+
+
+/* __mf_find_object[s] */
+
+/* Find overlapping live objecs between [low,high].  Return up to
+   max_objs of their pointers in objs[].  Return total count of
+   overlaps (may exceed max_objs). */
+
+unsigned
+__mf_find_objects2 (uintptr_t ptr_low, uintptr_t ptr_high,
+                    __mf_object_t **objs, unsigned max_objs, int type)
+{
+  unsigned count = 0;
+  mfsplay_tree t = __mf_object_tree (type);
+  mfsplay_tree_key k = (mfsplay_tree_key) ptr_low;
+  int direction;
+
+  mfsplay_tree_node n = mfsplay_tree_lookup (t, k);
+  /* An exact match for base address implies a hit.  */
+  if (n != NULL)
+    {
+      if (count < max_objs)
+        objs[count] = (__mf_object_t *) n->value;
+      count ++;
+    }
+
+  /* Iterate left then right near this key value to find all overlapping objects. */
+  for (direction = 0; direction < 2; direction ++)
+    {
+      /* Reset search origin.  */
+      k = (mfsplay_tree_key) ptr_low;
+
+      while (1)
+        {
+          __mf_object_t *obj;
+
+          n = (direction == 0 ? mfsplay_tree_successor (t, k) : mfsplay_tree_predecessor (t, k));
+          if (n == NULL) break;
+          obj = (__mf_object_t *) n->value;
+
+          if (! (obj->low <= ptr_high && obj->high >= ptr_low)) /* No overlap? */
+            break;
+
+          if (count < max_objs)
+            objs[count] = (__mf_object_t *) n->value;
+          count ++;
+
+          k = (mfsplay_tree_key) obj->low;
+        }
+    }
+
+  return count;
+}
+
+
+unsigned
+__mf_find_objects (uintptr_t ptr_low, uintptr_t ptr_high,
+                   __mf_object_t **objs, unsigned max_objs)
+{
+  int type;
+  unsigned count = 0;
+
+  /* Search each splay tree for overlaps.  */
+  for (type = __MF_TYPE_NOACCESS; type <= __MF_TYPE_GUESS; type++)
+    {
+      unsigned c = __mf_find_objects2 (ptr_low, ptr_high, objs, max_objs, type);
+      if (c > max_objs)
+        {
+          max_objs = 0;
+          objs = NULL;
+        }
+      else /* NB: C may equal 0 */
+        {
+          max_objs -= c;
+          objs += c;
+        }
+      count += c;
+    }
+
+  return count;
+}
+
+
+
+/* __mf_link_object */
+
+static void
+__mf_link_object (__mf_object_t *node)
+{
+  mfsplay_tree t = __mf_object_tree (node->type);
+  mfsplay_tree_insert (t, (mfsplay_tree_key) node->low, (mfsplay_tree_value) node);
+}
+
+/* __mf_unlink_object */
+
+static void
+__mf_unlink_object (__mf_object_t *node)
+{
+  mfsplay_tree t = __mf_object_tree (node->type);
+  mfsplay_tree_remove (t, (mfsplay_tree_key) node->low);
+}
+
+/* __mf_find_dead_objects */
+
+/* Find overlapping dead objecs between [low,high].  Return up to
+   max_objs of their pointers in objs[].  Return total count of
+   overlaps (may exceed max_objs).  */
+
+static unsigned
+__mf_find_dead_objects (uintptr_t low, uintptr_t high,
+                        __mf_object_t **objs, unsigned max_objs)
+{
+  if (__mf_opts.persistent_count > 0)
+    {
+      unsigned count = 0;
+      unsigned recollection = 0;
+      unsigned row = 0;
+
+      assert (low <= high);
+      assert (max_objs == 0 || objs != NULL);
+
+      /* Widen the search from the most recent plots in each row, looking
+         backward in time.  */
+      recollection = 0;
+      while (recollection < __mf_opts.persistent_count)
+        {
+          count = 0;
+
+          for (row = 0; row <= __MF_TYPE_MAX_CEM; row ++)
+            {
+              unsigned plot;
+              unsigned i;
+
+              plot = __mf_object_dead_head [row];
+              for (i = 0; i <= recollection; i ++)
+                {
+                  __mf_object_t *obj;
+
+                  /* Look backward through row: it's a circular buffer.  */
+                  if (plot > 0) plot --;
+                  else plot = __mf_opts.persistent_count - 1;
+
+                  obj = __mf_object_cemetary [row][plot];
+                  if (obj && obj->low <= high && obj->high >= low)
+                    {
+                      /* Found an overlapping dead object!  */
+                      if (count < max_objs)
+                        objs [count] = obj;
+                      count ++;
+                    }
+                }
+            }
+
+          if (count)
+            break;
+
+          /* Look farther back in time.  */
+          recollection = (recollection * 2) + 1;
+        }
+
+      return count;
+    } else {
+      return 0;
+    }
+}
+
+/* __mf_describe_object */
+
+static void
+__mf_describe_object (__mf_object_t *obj)
+{
+  static unsigned epoch = 0;
+  if (obj == NULL)
+    {
+      epoch ++;
+      return;
+    }
+
+  if (__mf_opts.abbreviate && obj->description_epoch == epoch)
+    {
+      fprintf (stderr,
+               "mudflap %sobject %p: name=`%s'\n",
+               (obj->deallocated_p ? "dead " : ""),
+               (void *) obj, (obj->name ? obj->name : ""));
+      return;
+    }
+  else
+    obj->description_epoch = epoch;
+
+  fprintf (stderr,
+           "mudflap %sobject %p: name=`%s'\n"
+           "bounds=[%p,%p] size=%lu area=%s check=%ur/%uw liveness=%u%s\n"
+           "alloc time=%lu.%06lu pc=%p"
+#ifdef LIBMUDFLAPTH
+           " thread=%u"
+#endif
+           "\n",
+           (obj->deallocated_p ? "dead " : ""),
+           (void *) obj, (obj->name ? obj->name : ""),
+           (void *) obj->low, (void *) obj->high,
+           (unsigned long) (obj->high - obj->low + 1),
+           (obj->type == __MF_TYPE_NOACCESS ? "no-access" :
+            obj->type == __MF_TYPE_HEAP ? "heap" :
+            obj->type == __MF_TYPE_HEAP_I ? "heap-init" :
+            obj->type == __MF_TYPE_STACK ? "stack" :
+            obj->type == __MF_TYPE_STATIC ? "static" :
+            obj->type == __MF_TYPE_GUESS ? "guess" :
+            "unknown"),
+           obj->read_count, obj->write_count, obj->liveness,
+           obj->watching_p ? " watching" : "",
+           obj->alloc_time.tv_sec, obj->alloc_time.tv_usec,
+           (void *) obj->alloc_pc
+#ifdef LIBMUDFLAPTH
+           , (unsigned) obj->alloc_thread
+#endif
+           );
+
+  if (__mf_opts.backtrace > 0)
+  {
+    unsigned i;
+    for (i=0; i<obj->alloc_backtrace_size; i++)
+      fprintf (stderr, "      %s\n", obj->alloc_backtrace[i]);
+  }
+
+  if (__mf_opts.persistent_count > 0)
+    {
+      if (obj->deallocated_p)
+        {
+          fprintf (stderr, "dealloc time=%lu.%06lu pc=%p"
+#ifdef LIBMUDFLAPTH
+                   " thread=%u"
+#endif
+                   "\n",
+                   obj->dealloc_time.tv_sec, obj->dealloc_time.tv_usec,
+                   (void *) obj->dealloc_pc
+#ifdef LIBMUDFLAPTH
+                   , (unsigned) obj->dealloc_thread
+#endif
+                   );
+
+
+          if (__mf_opts.backtrace > 0)
+          {
+            unsigned i;
+            for (i=0; i<obj->dealloc_backtrace_size; i++)
+              fprintf (stderr, "      %s\n", obj->dealloc_backtrace[i]);
+          }
+        }
+    }
+}
+
+
+static int
+__mf_report_leaks_fn (mfsplay_tree_node n, void *param)
+{
+  __mf_object_t *node = (__mf_object_t *) n->value;
+  unsigned *count = (unsigned *) param;
+
+  if (count != NULL)
+    (*count) ++;
+
+  fprintf (stderr, "Leaked object %u:\n", (*count));
+  __mf_describe_object (node);
+
+  return 0;
+}
+
+
+static unsigned
+__mf_report_leaks ()
+{
+  unsigned count = 0;
+
+  (void) mfsplay_tree_foreach (__mf_object_tree (__MF_TYPE_HEAP),
+                             __mf_report_leaks_fn, & count);
+  (void) mfsplay_tree_foreach (__mf_object_tree (__MF_TYPE_HEAP_I),
+                             __mf_report_leaks_fn, & count);
+
+  return count;
+}
+
+/* ------------------------------------------------------------------------ */
+/* __mf_report */
+
+void
+__mf_report ()
+{
+  LOCKTH ();
+  BEGIN_RECURSION_PROTECT ();
+  __mfu_report ();
+  END_RECURSION_PROTECT ();
+  UNLOCKTH ();
+}
+
+void
+__mfu_report ()
+{
+  if (__mf_opts.collect_stats)
+    {
+      fprintf (stderr,
+               "*******\n"
+               "mudflap stats:\n"
+               "calls to __mf_check: %lu\n"
+               "         __mf_register: %lu [%luB, %luB, %luB, %luB, %luB]\n"
+               "         __mf_unregister: %lu [%luB]\n"
+               "         __mf_violation: [%lu, %lu, %lu, %lu, %lu]\n",
+               __mf_count_check,
+               __mf_count_register,
+               __mf_total_register_size[0], __mf_total_register_size[1],
+               __mf_total_register_size[2], __mf_total_register_size[3],
+               __mf_total_register_size[4], /* XXX */
+               __mf_count_unregister, __mf_total_unregister_size,
+               __mf_count_violation[0], __mf_count_violation[1],
+               __mf_count_violation[2], __mf_count_violation[3],
+               __mf_count_violation[4]);
+
+      fprintf (stderr,
+               "calls with reentrancy: %lu\n", __mf_reentrancy);
+#ifdef LIBMUDFLAPTH
+      fprintf (stderr,
+               "           lock contention: %lu\n", __mf_lock_contention);
+#endif
+
+      /* Lookup cache stats.  */
+      {
+        unsigned i;
+        unsigned max_reuse = 0;
+        unsigned num_used = 0;
+        unsigned num_unused = 0;
+
+        for (i = 0; i < LOOKUP_CACHE_SIZE; i++)
+          {
+            if (__mf_lookup_cache_reusecount[i])
+              num_used ++;
+            else
+              num_unused ++;
+            if (max_reuse < __mf_lookup_cache_reusecount[i])
+              max_reuse = __mf_lookup_cache_reusecount[i];
+          }
+        fprintf (stderr, "lookup cache slots used: %u  unused: %u  peak-reuse: %u\n",
+                 num_used, num_unused, max_reuse);
+      }
+
+      {
+        unsigned live_count;
+        live_count = __mf_find_objects (MINPTR, MAXPTR, NULL, 0);
+        fprintf (stderr, "number of live objects: %u\n", live_count);
+      }
+
+      if (__mf_opts.persistent_count > 0)
+        {
+          unsigned dead_count = 0;
+          unsigned row, plot;
+          for (row = 0; row <= __MF_TYPE_MAX_CEM; row ++)
+            for (plot = 0 ; plot < __mf_opts.persistent_count; plot ++)
+              if (__mf_object_cemetary [row][plot] != 0)
+                dead_count ++;
+          fprintf (stderr, "          zombie objects: %u\n", dead_count);
+        }
+    }
+  if (__mf_opts.print_leaks && (__mf_opts.mudflap_mode == mode_check))
+    {
+      unsigned l;
+      extern void * __mf_wrap_alloca_indirect (size_t c);
+
+      /* Free up any remaining alloca()'d blocks.  */
+      __mf_wrap_alloca_indirect (0);
+      __mf_describe_object (NULL); /* Reset description epoch.  */
+      l = __mf_report_leaks ();
+      fprintf (stderr, "number of leaked objects: %u\n", l);
+    }
+}
+
+/* __mf_backtrace */
+
+size_t
+__mf_backtrace (char ***symbols, void *guess_pc, unsigned guess_omit_levels)
+{
+  void ** pc_array;
+  unsigned pc_array_size = __mf_opts.backtrace + guess_omit_levels;
+  unsigned remaining_size;
+  unsigned omitted_size = 0;
+  unsigned i;
+  DECLARE (void, free, void *ptr);
+  DECLARE (void *, calloc, size_t c, size_t n);
+  DECLARE (void *, malloc, size_t n);
+
+  pc_array = CALL_REAL (calloc, pc_array_size, sizeof (void *) );
+#ifdef HAVE_BACKTRACE
+  pc_array_size = backtrace (pc_array, pc_array_size);
+#else
+#define FETCH(n) do { if (pc_array_size >= n) { \
+                 pc_array[n] = __builtin_return_address(n); \
+                 if (pc_array[n] == 0) pc_array_size = n; } } while (0)
+
+  /* Unroll some calls __builtin_return_address because this function
+     only takes a literal integer parameter.  */
+  FETCH (0);
+#if 0
+  /* XXX: __builtin_return_address sometimes crashes (!) on >0 arguments,
+     rather than simply returning 0.  :-(  */
+  FETCH (1);
+  FETCH (2);
+  FETCH (3);
+  FETCH (4);
+  FETCH (5);
+  FETCH (6);
+  FETCH (7);
+  FETCH (8);
+  if (pc_array_size > 8) pc_array_size = 9;
+#else
+  if (pc_array_size > 0) pc_array_size = 1;
+#endif
+
+#undef FETCH
+#endif
+
+  /* We want to trim the first few levels of the stack traceback,
+     since they contain libmudflap wrappers and junk.  If pc_array[]
+     ends up containing a non-NULL guess_pc, then trim everything
+     before that.  Otherwise, omit the first guess_omit_levels
+     entries. */
+
+  if (guess_pc != NULL)
+    for (i=0; i<pc_array_size; i++)
+      if (pc_array [i] == guess_pc)
+        omitted_size = i;
+
+  if (omitted_size == 0) /* No match? */
+    if (pc_array_size > guess_omit_levels)
+      omitted_size = guess_omit_levels;
+
+  remaining_size = pc_array_size - omitted_size;
+
+#ifdef HAVE_BACKTRACE_SYMBOLS
+  *symbols = backtrace_symbols (pc_array + omitted_size, remaining_size);
+#else
+  {
+    /* Let's construct a buffer by hand.  It will have <remaining_size>
+       char*'s at the front, pointing at individual strings immediately
+       afterwards.  */
+    void *buffer;
+    char *chars;
+    char **pointers;
+    enum { perline = 30 };
+    buffer = CALL_REAL (malloc, remaining_size * (perline + sizeof(char *)));
+    pointers = (char **) buffer;
+    chars = (char *)buffer + (remaining_size * sizeof (char *));
+    for (i = 0; i < remaining_size; i++)
+      {
+        pointers[i] = chars;
+        sprintf (chars, "[0x%p]", pc_array [omitted_size + i]);
+        chars = chars + perline;
+      }
+    *symbols = pointers;
+  }
+#endif
+  CALL_REAL (free, pc_array);
+
+  return remaining_size;
+}
+
+/* ------------------------------------------------------------------------ */
+/* __mf_violation */
+
+void
+__mf_violation (void *ptr, size_t sz, uintptr_t pc,
+                const char *location, int type)
+{
+  char buf [128];
+  static unsigned violation_number;
+  DECLARE(void, free, void *ptr);
+
+  TRACE ("violation pc=%p location=%s type=%d ptr=%p size=%lu\n",
+         (void *) pc,
+         (location != NULL ? location : ""), type, ptr, (unsigned long) sz);
+
+  if (__mf_opts.collect_stats)
+    __mf_count_violation [(type < 0) ? 0 :
+                          (type > __MF_VIOL_WATCH) ? 0 :
+                          type] ++;
+
+  /* Print out a basic warning message.  */
+  if (__mf_opts.verbose_violations)
+  {
+    unsigned dead_p;
+    unsigned num_helpful = 0;
+    struct timeval now = { 0, 0 };
+#if HAVE_GETTIMEOFDAY
+    gettimeofday (& now, NULL);
+#endif
+
+    violation_number ++;
+    fprintf (stderr,
+             "*******\n"
+             "mudflap violation %u (%s): time=%lu.%06lu "
+             "ptr=%p size=%lu\npc=%p%s%s%s\n",
+             violation_number,
+             ((type == __MF_VIOL_READ) ? "check/read" :
+              (type == __MF_VIOL_WRITE) ? "check/write" :
+              (type == __MF_VIOL_REGISTER) ? "register" :
+              (type == __MF_VIOL_UNREGISTER) ? "unregister" :
+              (type == __MF_VIOL_WATCH) ? "watch" : "unknown"),
+             now.tv_sec, now.tv_usec,
+             (void *) ptr, (unsigned long)sz, (void *) pc,
+             (location != NULL ? " location=`" : ""),
+             (location != NULL ? location : ""),
+             (location != NULL ? "'" : ""));
+
+    if (__mf_opts.backtrace > 0)
+      {
+        char ** symbols;
+        unsigned i, num;
+
+        num = __mf_backtrace (& symbols, (void *) pc, 2);
+        /* Note: backtrace_symbols calls malloc().  But since we're in
+           __mf_violation and presumably __mf_check, it'll detect
+           recursion, and not put the new string into the database.  */
+
+        for (i=0; i<num; i++)
+          fprintf (stderr, "      %s\n", symbols[i]);
+
+        /* Calling free() here would trigger a violation.  */
+        CALL_REAL(free, symbols);
+      }
+
+
+    /* Look for nearby objects.  For this, we start with s_low/s_high
+       pointing to the given area, looking for overlapping objects.
+       If none show up, widen the search area and keep looking. */
+
+    if (sz == 0) sz = 1;
+
+    for (dead_p = 0; dead_p <= 1; dead_p ++) /* for dead_p in 0 1 */
+      {
+        enum {max_objs = 3}; /* magic */
+        __mf_object_t *objs[max_objs];
+        unsigned num_objs = 0;
+        uintptr_t s_low, s_high;
+        unsigned tries = 0;
+        unsigned i;
+
+        s_low = (uintptr_t) ptr;
+        s_high = CLAMPSZ (ptr, sz);
+
+        while (tries < 16) /* magic */
+          {
+            if (dead_p)
+              num_objs = __mf_find_dead_objects (s_low, s_high, objs, max_objs);
+            else
+              num_objs = __mf_find_objects (s_low, s_high, objs, max_objs);
+
+            if (num_objs) /* good enough */
+              break;
+
+            tries ++;
+
+            /* XXX: tune this search strategy.  It's too dependent on
+             sz, which can vary from 1 to very big (when array index
+             checking) numbers. */
+            s_low = CLAMPSUB (s_low, (sz * tries * tries));
+            s_high = CLAMPADD (s_high, (sz * tries * tries));
+          }
+
+        for (i = 0; i < min (num_objs, max_objs); i++)
+          {
+            __mf_object_t *obj = objs[i];
+            uintptr_t low = (uintptr_t) ptr;
+            uintptr_t high = CLAMPSZ (ptr, sz);
+            unsigned before1 = (low < obj->low) ? obj->low - low : 0;
+            unsigned after1 = (low > obj->high) ? low - obj->high : 0;
+            unsigned into1 = (high >= obj->low && low <= obj->high) ? low - obj->low : 0;
+            unsigned before2 = (high < obj->low) ? obj->low - high : 0;
+            unsigned after2 = (high > obj->high) ? high - obj->high : 0;
+            unsigned into2 = (high >= obj->low && low <= obj->high) ? high - obj->low : 0;
+
+            fprintf (stderr, "Nearby object %u: checked region begins %uB %s and ends %uB %s\n",
+                     num_helpful + i + 1,
+                     (before1 ? before1 : after1 ? after1 : into1),
+                     (before1 ? "before" : after1 ? "after" : "into"),
+                     (before2 ? before2 : after2 ? after2 : into2),
+                     (before2 ? "before" : after2 ? "after" : "into"));
+            __mf_describe_object (obj);
+          }
+        num_helpful += num_objs;
+      }
+
+    fprintf (stderr, "number of nearby objects: %u\n", num_helpful);
+  }
+
+  /* How to finally handle this violation?  */
+  switch (__mf_opts.violation_mode)
+    {
+    case viol_nop:
+      break;
+    case viol_segv:
+      kill (getpid(), SIGSEGV);
+      break;
+    case viol_abort:
+      abort ();
+      break;
+    case viol_gdb:
+
+      snprintf (buf, 128, "gdb --pid=%u", (unsigned) getpid ());
+      system (buf);
+      /* XXX: should probably fork() && sleep(GDB_WAIT_PARAMETER)
+      instead, and let the forked child execlp() gdb.  That way, this
+      subject process can be resumed under the supervision of gdb.
+      This can't happen now, since system() only returns when gdb
+      dies.  In that case, we need to beware of starting a second
+      concurrent gdb child upon the next violation.  (But if the first
+      gdb dies, then starting a new one is appropriate.)  */
+      break;
+    }
+}
+
+/* ------------------------------------------------------------------------ */
+
+
+unsigned __mf_watch (void *ptr, size_t sz)
+{
+  unsigned rc;
+  LOCKTH ();
+  BEGIN_RECURSION_PROTECT ();
+  rc = __mf_watch_or_not (ptr, sz, 1);
+  END_RECURSION_PROTECT ();
+  UNLOCKTH ();
+  return rc;
+}
+
+unsigned __mf_unwatch (void *ptr, size_t sz)
+{
+  unsigned rc;
+  LOCKTH ();
+  rc = __mf_watch_or_not (ptr, sz, 0);
+  UNLOCKTH ();
+  return rc;
+}
+
+
+static unsigned
+__mf_watch_or_not (void *ptr, size_t sz, char flag)
+{
+  uintptr_t ptr_high = CLAMPSZ (ptr, sz);
+  uintptr_t ptr_low = (uintptr_t) ptr;
+  unsigned count = 0;
+
+  TRACE ("%s ptr=%p size=%lu\n",
+         (flag ? "watch" : "unwatch"), ptr, (unsigned long) sz);
+
+  switch (__mf_opts.mudflap_mode)
+    {
+    case mode_nop:
+    case mode_populate:
+    case mode_violate:
+      count = 0;
+      break;
+
+    case mode_check:
+      {
+        __mf_object_t **all_ovr_objs;
+        unsigned obj_count;
+        unsigned n;
+        DECLARE (void *, malloc, size_t c);
+        DECLARE (void, free, void *p);
+
+        obj_count = __mf_find_objects (ptr_low, ptr_high, NULL, 0);
+        VERBOSE_TRACE (" %u:", obj_count);
+
+        all_ovr_objs = CALL_REAL (malloc, (sizeof (__mf_object_t *) * obj_count));
+        if (all_ovr_objs == NULL) abort ();
+        n = __mf_find_objects (ptr_low, ptr_high, all_ovr_objs, obj_count);
+        assert (n == obj_count);
+
+        for (n = 0; n < obj_count; n ++)
+          {
+            __mf_object_t *obj = all_ovr_objs[n];
+
+            VERBOSE_TRACE (" [%p]", (void *) obj);
+            if (obj->watching_p != flag)
+              {
+                obj->watching_p = flag;
+                count ++;
+
+                /* Remove object from cache, to ensure next access
+                   goes through __mf_check().  */
+                if (flag)
+                  __mf_uncache_object (obj);
+              }
+          }
+        CALL_REAL (free, all_ovr_objs);
+      }
+      break;
+    }
+
+  return count;
+}
+
+
+void
+__mf_sigusr1_handler (int num)
+{
+  __mf_sigusr1_received ++;
+}
+
+/* Install or remove SIGUSR1 handler as necessary.
+   Also, respond to a received pending SIGUSR1.  */
+void
+__mf_sigusr1_respond ()
+{
+  static int handler_installed;
+
+#ifdef SIGUSR1
+  /* Manage handler */
+  if (__mf_opts.sigusr1_report && ! handler_installed)
+    {
+      signal (SIGUSR1, __mf_sigusr1_handler);
+      handler_installed = 1;
+    }
+  else if(! __mf_opts.sigusr1_report && handler_installed)
+    {
+      signal (SIGUSR1, SIG_DFL);
+      handler_installed = 0;
+    }
+#endif
+
+  /* Manage enqueued signals */
+  if (__mf_sigusr1_received > __mf_sigusr1_handled)
+    {
+      __mf_sigusr1_handled ++;
+      assert (__mf_get_state () == reentrant);
+      __mfu_report ();
+      handler_installed = 0; /* We may need to re-enable signal; this might be a SysV library. */
+    }
+}
+
+
+/* XXX: provide an alternative __assert_fail function that cannot
+   fail due to libmudflap infinite recursion.  */
+#ifndef NDEBUG
+
+static void
+write_itoa (int fd, unsigned n)
+{
+  enum x { bufsize = sizeof(n)*4 };
+  char buf [bufsize];
+  unsigned i;
+
+  for (i=0; i<bufsize-1; i++)
+    {
+      unsigned digit = n % 10;
+      buf[bufsize-2-i] = digit + '0';
+      n /= 10;
+      if (n == 0)
+        {
+          char *m = & buf [bufsize-2-i];
+          buf[bufsize-1] = '\0';
+          write (fd, m, strlen(m));
+          break;
+        }
+    }
+}
+
+
+void
+__assert_fail (const char *msg, const char *file, unsigned line, const char *func)
+{
+#define write2(string) write (2, (string), strlen ((string)));
+  write2("mf");
+#ifdef LIBMUDFLAPTH
+  write2("(");
+  write_itoa (2, (unsigned) pthread_self ());
+  write2(")");
+#endif
+  write2(": assertion failure: `");
+  write (2, msg, strlen (msg));
+  write2("' in ");
+  write (2, func, strlen (func));
+  write2(" at ");
+  write (2, file, strlen (file));
+  write2(":");
+  write_itoa (2, line);
+  write2("\n");
+#undef write2
+  abort ();
+}
+
+
+#endif
+
+
+
+/* Adapted splay tree code, originally from libiberty.  It has been
+   specialized for libmudflap as requested by RMS.  */
+
+static void
+mfsplay_tree_free (void *p)
+{
+  DECLARE (void, free, void *p);
+  CALL_REAL (free, p);
+}
+
+static void *
+mfsplay_tree_xmalloc (size_t s)
+{
+  DECLARE (void *, malloc, size_t s);
+  return CALL_REAL (malloc, s);
+}
+
+
+static void mfsplay_tree_splay (mfsplay_tree, mfsplay_tree_key);
+static mfsplay_tree_node mfsplay_tree_splay_helper (mfsplay_tree,
+                                                mfsplay_tree_key,
+                                                mfsplay_tree_node *,
+                                                mfsplay_tree_node *,
+                                                mfsplay_tree_node *);
+
+
+/* Help splay SP around KEY.  PARENT and GRANDPARENT are the parent
+   and grandparent, respectively, of NODE.  */
+
+static mfsplay_tree_node
+mfsplay_tree_splay_helper (mfsplay_tree sp,
+                         mfsplay_tree_key key,
+                         mfsplay_tree_node * node,
+                         mfsplay_tree_node * parent,
+                         mfsplay_tree_node * grandparent)
+{
+  mfsplay_tree_node *next;
+  mfsplay_tree_node n;
+  int comparison;
+
+  n = *node;
+
+  if (!n)
+    return *parent;
+
+  comparison = ((key > n->key) ? 1 : ((key < n->key) ? -1 : 0));
+
+  if (comparison == 0)
+    /* We've found the target.  */
+    next = 0;
+  else if (comparison < 0)
+    /* The target is to the left.  */
+    next = &n->left;
+  else
+    /* The target is to the right.  */
+    next = &n->right;
+
+  if (next)
+    {
+      /* Check whether our recursion depth is too high.  Abort this search,
+         and signal that a rebalance is required to continue.  */
+      if (sp->depth > sp->max_depth)
+        {
+          sp->rebalance_p = 1;
+          return n;
+         }
+
+      /* Continue down the tree.  */
+      sp->depth ++;
+      n = mfsplay_tree_splay_helper (sp, key, next, node, parent);
+      sp->depth --;
+
+      /* The recursive call will change the place to which NODE
+         points.  */
+      if (*node != n || sp->rebalance_p)
+        return n;
+    }
+
+  if (!parent)
+    /* NODE is the root.  We are done.  */
+    return n;
+
+  /* First, handle the case where there is no grandparent (i.e.,
+   *PARENT is the root of the tree.)  */
+  if (!grandparent)
+    {
+      if (n == (*parent)->left)
+        {
+          *node = n->right;
+          n->right = *parent;
+        }
+      else
+        {
+          *node = n->left;
+          n->left = *parent;
+        }
+      *parent = n;
+      return n;
+    }
+
+  /* Next handle the cases where both N and *PARENT are left children,
+     or where both are right children.  */
+  if (n == (*parent)->left && *parent == (*grandparent)->left)
+    {
+      mfsplay_tree_node p = *parent;
+
+      (*grandparent)->left = p->right;
+      p->right = *grandparent;
+      p->left = n->right;
+      n->right = p;
+      *grandparent = n;
+      return n;
+    }
+  else if (n == (*parent)->right && *parent == (*grandparent)->right)
+    {
+      mfsplay_tree_node p = *parent;
+
+      (*grandparent)->right = p->left;
+      p->left = *grandparent;
+      p->right = n->left;
+      n->left = p;
+      *grandparent = n;
+      return n;
+    }
+
+  /* Finally, deal with the case where N is a left child, but *PARENT
+     is a right child, or vice versa.  */
+  if (n == (*parent)->left)
+    {
+      (*parent)->left = n->right;
+      n->right = *parent;
+      (*grandparent)->right = n->left;
+      n->left = *grandparent;
+      *grandparent = n;
+      return n;
+    }
+  else
+    {
+      (*parent)->right = n->left;
+      n->left = *parent;
+      (*grandparent)->left = n->right;
+      n->right = *grandparent;
+      *grandparent = n;
+      return n;
+    }
+}
+
+
+
+static int
+mfsplay_tree_rebalance_helper1 (mfsplay_tree_node n, void *array_ptr)
+{
+  mfsplay_tree_node **p = array_ptr;
+  *(*p) = n;
+  (*p)++;
+  return 0;
+}
+
+
+static mfsplay_tree_node
+mfsplay_tree_rebalance_helper2 (mfsplay_tree_node * array, unsigned low,
+                              unsigned high)
+{
+  unsigned middle = low + (high - low) / 2;
+  mfsplay_tree_node n = array[middle];
+
+  /* Note that since we're producing a balanced binary tree, it is not a problem
+     that this function is recursive.  */
+  if (low + 1 <= middle)
+    n->left = mfsplay_tree_rebalance_helper2 (array, low, middle - 1);
+  else
+    n->left = NULL;
+
+  if (middle + 1 <= high)
+    n->right = mfsplay_tree_rebalance_helper2 (array, middle + 1, high);
+  else
+    n->right = NULL;
+
+  return n;
+}
+
+
+/* Rebalance the entire tree.  Do this by copying all the node
+   pointers into an array, then cleverly re-linking them.  */
+static void
+mfsplay_tree_rebalance (mfsplay_tree sp)
+{
+  mfsplay_tree_node *all_nodes, *all_nodes_1;
+
+  if (sp->num_keys <= 2)
+    return;
+
+  all_nodes = mfsplay_tree_xmalloc (sizeof (mfsplay_tree_node) * sp->num_keys);
+
+  /* Traverse all nodes to copy their addresses into this array.  */
+  all_nodes_1 = all_nodes;
+  mfsplay_tree_foreach (sp, mfsplay_tree_rebalance_helper1,
+                      (void *) &all_nodes_1);
+
+  /* Relink all the nodes.  */
+  sp->root = mfsplay_tree_rebalance_helper2 (all_nodes, 0, sp->num_keys - 1);
+
+  mfsplay_tree_free (all_nodes);
+}
+
+
+/* Splay SP around KEY.  */
+static void
+mfsplay_tree_splay (mfsplay_tree sp, mfsplay_tree_key key)
+{
+  if (sp->root == 0)
+    return;
+
+  /* If we just splayed the tree with the same key, do nothing.  */
+  if (sp->last_splayed_key_p &&
+      (sp->last_splayed_key == key))
+    return;
+
+  /* Compute a maximum recursion depth for a splay tree with NUM nodes.
+     The idea is to limit excessive stack usage if we're facing
+     degenerate access patterns.  Unfortunately such patterns can occur
+     e.g. during static initialization, where many static objects might
+     be registered in increasing address sequence, or during a case where
+     large tree-like heap data structures are allocated quickly.
+
+     On x86, this corresponds to roughly 200K of stack usage.
+     XXX: For libmudflapth, this could be a function of __mf_opts.thread_stack.  */
+  sp->max_depth = 2500;
+  sp->rebalance_p = sp->depth = 0;
+
+  mfsplay_tree_splay_helper (sp, key, &sp->root, NULL, NULL);
+  if (sp->rebalance_p)
+    {
+      mfsplay_tree_rebalance (sp);
+
+      sp->rebalance_p = sp->depth = 0;
+      mfsplay_tree_splay_helper (sp, key, &sp->root, NULL, NULL);
+
+      if (sp->rebalance_p)
+        abort ();
+    }
+
+
+  /* Cache this splay key. */
+  sp->last_splayed_key = key;
+  sp->last_splayed_key_p = 1;
+}
+
+
+
+/* Allocate a new splay tree.  */
+static mfsplay_tree
+mfsplay_tree_new ()
+{
+  mfsplay_tree sp = mfsplay_tree_xmalloc (sizeof (struct mfsplay_tree_s));
+  sp->root = NULL;
+  sp->last_splayed_key_p = 0;
+  sp->num_keys = 0;
+
+  return sp;
+}
+
+
+
+/* Insert a new node (associating KEY with DATA) into SP.  If a
+   previous node with the indicated KEY exists, its data is replaced
+   with the new value.  Returns the new node.  */
+static mfsplay_tree_node
+mfsplay_tree_insert (mfsplay_tree sp, mfsplay_tree_key key, mfsplay_tree_value value)
+{
+  int comparison = 0;
+
+  mfsplay_tree_splay (sp, key);
+
+  if (sp->root)
+    comparison = ((sp->root->key > key) ? 1 :
+                  ((sp->root->key < key) ? -1 : 0));
+
+  if (sp->root && comparison == 0)
+    {
+      /* If the root of the tree already has the indicated KEY, just
+         replace the value with VALUE.  */
+      sp->root->value = value;
+    }
+  else
+    {
+      /* Create a new node, and insert it at the root.  */
+      mfsplay_tree_node node;
+
+      node = mfsplay_tree_xmalloc (sizeof (struct mfsplay_tree_node_s));
+      node->key = key;
+      node->value = value;
+      sp->num_keys++;
+      if (!sp->root)
+        node->left = node->right = 0;
+      else if (comparison < 0)
+        {
+          node->left = sp->root;
+          node->right = node->left->right;
+          node->left->right = 0;
+        }
+      else
+        {
+          node->right = sp->root;
+          node->left = node->right->left;
+          node->right->left = 0;
+        }
+
+      sp->root = node;
+      sp->last_splayed_key_p = 0;
+    }
+
+  return sp->root;
+}
+
+/* Remove KEY from SP.  It is not an error if it did not exist.  */
+
+static void
+mfsplay_tree_remove (mfsplay_tree sp, mfsplay_tree_key key)
+{
+  mfsplay_tree_splay (sp, key);
+  sp->last_splayed_key_p = 0;
+  if (sp->root && (sp->root->key == key))
+    {
+      mfsplay_tree_node left, right;
+      left = sp->root->left;
+      right = sp->root->right;
+      /* Delete the root node itself.  */
+      mfsplay_tree_free (sp->root);
+      sp->num_keys--;
+      /* One of the children is now the root.  Doesn't matter much
+         which, so long as we preserve the properties of the tree.  */
+      if (left)
+        {
+          sp->root = left;
+          /* If there was a right child as well, hang it off the
+             right-most leaf of the left child.  */
+          if (right)
+            {
+              while (left->right)
+                left = left->right;
+              left->right = right;
+            }
+        }
+      else
+        sp->root = right;
+    }
+}
+
+/* Lookup KEY in SP, returning VALUE if present, and NULL
+   otherwise.  */
+
+static mfsplay_tree_node
+mfsplay_tree_lookup (mfsplay_tree sp, mfsplay_tree_key key)
+{
+  mfsplay_tree_splay (sp, key);
+  if (sp->root && (sp->root->key == key))
+    return sp->root;
+  else
+    return 0;
+}
+
+
+/* Return the immediate predecessor KEY, or NULL if there is no
+   predecessor.  KEY need not be present in the tree.  */
+
+static mfsplay_tree_node
+mfsplay_tree_predecessor (mfsplay_tree sp, mfsplay_tree_key key)
+{
+  int comparison;
+  mfsplay_tree_node node;
+  /* If the tree is empty, there is certainly no predecessor.  */
+  if (!sp->root)
+    return NULL;
+  /* Splay the tree around KEY.  That will leave either the KEY
+     itself, its predecessor, or its successor at the root.  */
+  mfsplay_tree_splay (sp, key);
+  comparison = ((sp->root->key > key) ? 1 :
+                ((sp->root->key < key) ? -1 : 0));
+
+  /* If the predecessor is at the root, just return it.  */
+  if (comparison < 0)
+    return sp->root;
+  /* Otherwise, find the rightmost element of the left subtree.  */
+  node = sp->root->left;
+  if (node)
+    while (node->right)
+      node = node->right;
+  return node;
+}
+
+/* Return the immediate successor KEY, or NULL if there is no
+   successor.  KEY need not be present in the tree.  */
+
+static mfsplay_tree_node
+mfsplay_tree_successor (mfsplay_tree sp, mfsplay_tree_key key)
+{
+  int comparison;
+  mfsplay_tree_node node;
+  /* If the tree is empty, there is certainly no successor.  */
+  if (!sp->root)
+    return NULL;
+  /* Splay the tree around KEY.  That will leave either the KEY
+     itself, its predecessor, or its successor at the root.  */
+  mfsplay_tree_splay (sp, key);
+  comparison = ((sp->root->key > key) ? 1 :
+                ((sp->root->key < key) ? -1 : 0));
+  /* If the successor is at the root, just return it.  */
+  if (comparison > 0)
+    return sp->root;
+  /* Otherwise, find the leftmost element of the right subtree.  */
+  node = sp->root->right;
+  if (node)
+    while (node->left)
+      node = node->left;
+  return node;
+}
+
+/* Call FN, passing it the DATA, for every node in SP, following an
+   in-order traversal.  If FN every returns a non-zero value, the
+   iteration ceases immediately, and the value is returned.
+   Otherwise, this function returns 0.
+
+   This function simulates recursion using dynamically allocated
+   arrays, since it may be called from mfsplay_tree_rebalance(), which
+   in turn means that the tree is already uncomfortably deep for stack
+   space limits.  */
+static int
+mfsplay_tree_foreach (mfsplay_tree st, mfsplay_tree_foreach_fn fn, void *data)
+{
+  mfsplay_tree_node *stack1;
+  char *stack2;
+  unsigned sp;
+  int val = 0;
+  enum s { s_left, s_here, s_right, s_up };
+
+  if (st->root == NULL) /* => num_keys == 0 */
+    return 0;
+
+  stack1 = mfsplay_tree_xmalloc (sizeof (mfsplay_tree_node) * st->num_keys);
+  stack2 = mfsplay_tree_xmalloc (sizeof (char) * st->num_keys);
+
+  sp = 0;
+  stack1 [sp] = st->root;
+  stack2 [sp] = s_left;
+
+  while (1)
+    {
+      mfsplay_tree_node n;
+      enum s s;
+
+      n = stack1 [sp];
+      s = stack2 [sp];
+
+      /* Handle each of the four possible states separately.  */
+
+      /* 1: We're here to traverse the left subtree (if any).  */
+      if (s == s_left)
+        {
+          stack2 [sp] = s_here;
+          if (n->left != NULL)
+            {
+              sp ++;
+              stack1 [sp] = n->left;
+              stack2 [sp] = s_left;
+            }
+        }
+
+      /* 2: We're here to traverse this node.  */
+      else if (s == s_here)
+        {
+          stack2 [sp] = s_right;
+          val = (*fn) (n, data);
+          if (val) break;
+        }
+
+      /* 3: We're here to traverse the right subtree (if any).  */
+      else if (s == s_right)
+        {
+          stack2 [sp] = s_up;
+          if (n->right != NULL)
+            {
+              sp ++;
+              stack1 [sp] = n->right;
+              stack2 [sp] = s_left;
+            }
+        }
+
+      /* 4: We're here after both subtrees (if any) have been traversed.  */
+      else if (s == s_up)
+        {
+          /* Pop the stack.  */
+          if (sp == 0) break; /* Popping off the root note: we're finished!  */
+          sp --;
+        }
+
+      else
+        abort ();
+    }
+
+  mfsplay_tree_free (stack1);
+  mfsplay_tree_free (stack2);
+  return val;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/mf-runtime.h
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/mf-runtime.h?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/mf-runtime.h (added)
+++ llvm-gcc-4.2/trunk/libmudflap/mf-runtime.h Thu Nov  8 16:56:19 2007
@@ -0,0 +1,249 @@
+/* Implementation header for mudflap runtime library.
+   Mudflap: narrow-pointer bounds-checking by tree rewriting.
+   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Contributed by Frank Ch. Eigler <fche at redhat.com>
+   and Graydon Hoare <graydon at redhat.com>
+
+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 2, or (at your option) any later
+version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combine
+executable.)
+
+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 COPYING.  If not, write to the Free
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.  */
+
+/* Public libmudflap declarations -*- C -*- */
+
+#ifndef MF_RUNTIME_H
+#define MF_RUNTIME_H
+
+typedef void *__mf_ptr_t;
+typedef unsigned int __mf_uintptr_t __attribute__ ((__mode__ (__pointer__)));
+typedef __SIZE_TYPE__ __mf_size_t;
+
+/* Global declarations used by instrumentation.  When _MUDFLAP is
+   defined, these have been auto-declared by the compiler and we
+   should not declare them again (ideally we *would* declare them
+   again, to verify that the compiler's declarations match the
+   library's, but the C++ front end has no mechanism for allowing
+   the re-definition of a structure type).  */
+#ifndef _MUDFLAP
+struct __mf_cache { __mf_uintptr_t low; __mf_uintptr_t high; };
+extern struct __mf_cache __mf_lookup_cache [];
+extern __mf_uintptr_t __mf_lc_mask;
+extern unsigned char __mf_lc_shift;
+#endif
+
+/* Multithreading support.  */
+#ifdef _MUDFLAPTH
+/* extern pthread_mutex_t __mf_biglock; */
+#ifndef _REENTRANT
+#define _REENTRANT
+#endif
+#ifndef _THREAD_SAFE
+#define _THREAD_SAFE
+#endif
+#endif
+
+/* Codes to describe the type of access to check: __mf_check arg 3 */
+
+#define __MF_CHECK_READ 0
+#define __MF_CHECK_WRITE 1
+
+
+/* Codes to describe a region of memory being registered: __mf_*register arg 3 */
+
+#define __MF_TYPE_NOACCESS 0
+#define __MF_TYPE_HEAP 1
+#define __MF_TYPE_HEAP_I 2
+#define __MF_TYPE_STACK 3
+#define __MF_TYPE_STATIC 4
+#define __MF_TYPE_GUESS 5
+
+
+/* The public mudflap API */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void __mf_check (void *ptr, __mf_size_t sz, int type, const char *location)
+       __attribute((nothrow));
+extern void __mf_register (void *ptr, __mf_size_t sz, int type, const char *name)
+       __attribute((nothrow));
+extern void __mf_unregister (void *ptr, __mf_size_t sz, int type)
+       __attribute((nothrow));
+extern unsigned __mf_watch (void *ptr, __mf_size_t sz);
+extern unsigned __mf_unwatch (void *ptr, __mf_size_t sz);
+extern void __mf_report ();
+extern int __mf_set_options (const char *opts);
+
+
+/* Redirect some standard library functions to libmudflap.  These are
+   done by simple #define rather than linker wrapping, since only
+   instrumented modules are meant to be affected.  */
+
+#ifdef _MUDFLAP
+#pragma redefine_extname memcpy __mfwrap_memcpy
+#pragma redefine_extname memmove __mfwrap_memmove
+#pragma redefine_extname memset __mfwrap_memset
+#pragma redefine_extname memcmp __mfwrap_memcmp
+#pragma redefine_extname memchr __mfwrap_memchr
+#pragma redefine_extname memrchr __mfwrap_memrchr
+#pragma redefine_extname strcpy __mfwrap_strcpy
+#pragma redefine_extname strncpy __mfwrap_strncpy
+#pragma redefine_extname strcat __mfwrap_strcat
+#pragma redefine_extname strncat __mfwrap_strncat
+#pragma redefine_extname strcmp __mfwrap_strcmp
+#pragma redefine_extname strcasecmp __mfwrap_strcasecmp
+#pragma redefine_extname strncmp __mfwrap_strncmp
+#pragma redefine_extname strncasecmp __mfwrap_strncasecmp
+#pragma redefine_extname strdup __mfwrap_strdup
+#pragma redefine_extname strndup __mfwrap_strndup
+#pragma redefine_extname strchr __mfwrap_strchr
+#pragma redefine_extname strrchr __mfwrap_strrchr
+#pragma redefine_extname strstr __mfwrap_strstr
+#pragma redefine_extname memmem __mfwrap_memmem
+#pragma redefine_extname strlen __mfwrap_strlen
+#pragma redefine_extname strnlen __mfwrap_strnlen
+#pragma redefine_extname bzero __mfwrap_bzero
+#pragma redefine_extname bcopy __mfwrap_bcopy
+#pragma redefine_extname bcmp __mfwrap_bcmp
+#pragma redefine_extname index __mfwrap_index
+#pragma redefine_extname rindex __mfwrap_rindex
+#pragma redefine_extname asctime __mfwrap_asctime
+#pragma redefine_extname ctime __mfwrap_ctime
+#pragma redefine_extname gmtime __mfwrap_gmtime
+#pragma redefine_extname localtime __mfwrap_localtime
+#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
+#pragma redefine_extname fgetc __mfwrap_fgetc
+#pragma redefine_extname fgets __mfwrap_fgets
+#pragma redefine_extname getc __mfwrap_getc
+#pragma redefine_extname gets __mfwrap_gets
+#pragma redefine_extname ungetc __mfwrap_ungetc
+#pragma redefine_extname fputc __mfwrap_fputc
+#pragma redefine_extname fputs __mfwrap_fputs
+#pragma redefine_extname putc __mfwrap_putc
+#pragma redefine_extname puts __mfwrap_puts
+#pragma redefine_extname clearerr __mfwrap_clearerr
+#pragma redefine_extname feof __mfwrap_feof
+#pragma redefine_extname ferror __mfwrap_ferror
+#pragma redefine_extname fileno __mfwrap_fileno
+#pragma redefine_extname printf __mfwrap_printf
+#pragma redefine_extname fprintf __mfwrap_fprintf
+#pragma redefine_extname sprintf __mfwrap_sprintf
+#pragma redefine_extname snprintf __mfwrap_snprintf
+#pragma redefine_extname vprintf __mfwrap_vprintf
+#pragma redefine_extname vfprintf __mfwrap_vfprintf
+#pragma redefine_extname vsprintf __mfwrap_vsprintf
+#pragma redefine_extname vsnprintf __mfwrap_vsnprintf
+#pragma redefine_extname access __mfwrap_access
+#pragma redefine_extname remove __mfwrap_remove
+#pragma redefine_extname fflush __mfwrap_fflush
+#pragma redefine_extname fseek __mfwrap_fseek
+#pragma redefine_extname ftell __mfwrap_ftell
+#pragma redefine_extname rewind __mfwrap_rewind
+#pragma redefine_extname fgetpos __mfwrap_fgetpos
+#pragma redefine_extname fsetpos __mfwrap_fsetpos
+#pragma redefine_extname stat __mfwrap_stat
+#pragma redefine_extname fstat __mfwrap_fstat
+#pragma redefine_extname lstat __mfwrap_lstat
+#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
+#pragma redefine_extname recv __mfwrap_recv
+#pragma redefine_extname recvfrom __mfwrap_recvfrom
+#pragma redefine_extname recvmsg __mfwrap_recvmsg
+#pragma redefine_extname send __mfwrap_send
+#pragma redefine_extname sendto __mfwrap_sendto
+#pragma redefine_extname sendmsg __mfwrap_sendmsg
+#pragma redefine_extname setsockopt __mfwrap_setsockopt
+#pragma redefine_extname getsockopt __mfwrap_getsockopt
+#pragma redefine_extname accept __mfwrap_accept
+#pragma redefine_extname bind __mfwrap_bind
+#pragma redefine_extname connect __mfwrap_connect
+#pragma redefine_extname gethostname __mfwrap_gethostname
+#pragma redefine_extname sethostname __mfwrap_sethostname
+#pragma redefine_extname gethostbyname __mfwrap_gethostbyname
+#pragma redefine_extname wait __mfwrap_wait
+#pragma redefine_extname waitpid __mfwrap_waitpid
+#pragma redefine_extname popen __mfwrap_popen
+#pragma redefine_extname pclose __mfwrap_pclose
+#pragma redefine_extname execve __mfwrap_execve
+#pragma redefine_extname execv __mfwrap_execv
+#pragma redefine_extname execvp __mfwrap_execvp
+#pragma redefine_extname system __mfwrap_system
+#pragma redefine_extname dlopen __mfwrap_dlopen
+#pragma redefine_extname dlerror __mfwrap_dlerror
+#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
+#pragma redefine_extname semop __mfwrap_semop
+#pragma redefine_extname semctl __mfwrap_semctl
+#pragma redefine_extname shmctl __mfwrap_shmctl
+#pragma redefine_extname shmat __mfwrap_shmat
+#pragma redefine_extname shmdt __mfwrap_shmdt
+#pragma redefine_extname __ctype_b_loc __mfwrap___ctype_b_loc
+#pragma redefine_extname __ctype_toupper_loc __mfwrap___ctype_toupper_loc
+#pragma redefine_extname __ctype_tolower_loc __mfwrap___ctype_tolower_loc
+#pragma redefine_extname getlogin __mfwrap_getlogin
+#pragma redefine_extname cuserid __mfwrap_cuserid
+#pragma redefine_extname getpwnam __mfwrap_getpwnam
+#pragma redefine_extname getpwuid __mfwrap_getpwuid
+#pragma redefine_extname getgrnam __mfwrap_getgrnam
+#pragma redefine_extname getgrgid __mfwrap_getgrgid
+#pragma redefine_extname getservent __mfwrap_getservent
+#pragma redefine_extname getservbyname __mfwrap_getservbyname
+#pragma redefine_extname getservbyport __mfwrap_getservbyport
+#pragma redefine_extname gai_strerror __mfwrap_gai_strerror
+#pragma redefine_extname getmntent __mfwrap_getmntent
+#pragma redefine_extname inet_ntoa __mfwrap_inet_ntoa
+#pragma redefine_extname getprotoent __mfwrap_getprotoent
+#pragma redefine_extname getprotobyname __mfwrap_getprotobyname
+#pragma redefine_extname getprotobynumber __mfwrap_getprotobynumber
+
+/* Disable glibc macros.  */
+#define __NO_STRING_INLINES
+
+#endif /* _MUDFLAP */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MF_RUNTIME_H */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.am
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.am?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.am (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.am Thu Nov  8 16:56:19 2007
@@ -0,0 +1,11 @@
+## Process this with automake to create Makefile.in
+
+AUTOMAKE_OPTIONS = foreign dejagnu
+
+EXPECT = `if [ -f ../../expect/expect ] ; then \
+	  echo ../../expect/expect ; \
+	  else echo expect ; fi`
+
+RUNTEST = `if [ -f ${srcdir}/../../dejagnu/runtest ] ; then \
+	   echo ${srcdir}/../../dejagnu/runtest ; \
+	   else echo runtest ;  fi`

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.in
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.in?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.in (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/Makefile.in Thu Nov  8 16:56:19 2007
@@ -0,0 +1,373 @@
+# Makefile.in generated by automake 1.9.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+ at SET_MAKE@
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ..
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+subdir = testsuite
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \
+	$(srcdir)/mfconfig.exp.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \
+	$(top_srcdir)/../config/depstand.m4 \
+	$(top_srcdir)/../config/enable.m4 \
+	$(top_srcdir)/../config/lead-dot.m4 \
+	$(top_srcdir)/../config/tls.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/../libtool.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES = mfconfig.exp
+SOURCES =
+DIST_SOURCES =
+DEJATOOL = $(PACKAGE)
+RUNTESTDEFAULTFLAGS = --tool $$tool --srcdir $$srcdir
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LIBMUDFLAPTH_FALSE = @LIBMUDFLAPTH_FALSE@
+LIBMUDFLAPTH_TRUE = @LIBMUDFLAPTH_TRUE@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MF_HAVE_STDINT_H = @MF_HAVE_STDINT_H@
+MF_HAVE_UINTPTR_T = @MF_HAVE_UINTPTR_T@
+NM = @NM@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SECTION_FLAGS = @SECTION_FLAGS@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_NM = @ac_ct_NM@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_libmudflapth = @build_libmudflapth@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+enable_shared = @enable_shared@
+enable_static = @enable_static@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+multi_basedir = @multi_basedir@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_noncanonical = @target_noncanonical@
+target_os = @target_os@
+target_vendor = @target_vendor@
+toolexecdir = @toolexecdir@
+toolexeclibdir = @toolexeclibdir@
+AUTOMAKE_OPTIONS = foreign dejagnu
+EXPECT = `if [ -f ../../expect/expect ] ; then \
+	  echo ../../expect/expect ; \
+	  else echo expect ; fi`
+
+RUNTEST = `if [ -f ${srcdir}/../../dejagnu/runtest ] ; then \
+	   echo ${srcdir}/../../dejagnu/runtest ; \
+	   else echo runtest ;  fi`
+
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  testsuite/Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign  testsuite/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+mfconfig.exp: $(top_builddir)/config.status $(srcdir)/mfconfig.exp.in
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+tags: TAGS
+TAGS:
+
+ctags: CTAGS
+CTAGS:
+
+
+check-DEJAGNU: site.exp
+	srcdir=`$(am__cd) $(srcdir) && pwd`; export srcdir; \
+	EXPECT=$(EXPECT); export EXPECT; \
+	runtest=$(RUNTEST); \
+	if $(SHELL) -c "$$runtest --version" > /dev/null 2>&1; then \
+	  l='$(DEJATOOL)'; for tool in $$l; do \
+	    $$runtest $(AM_RUNTESTFLAGS) $(RUNTESTDEFAULTFLAGS) $(RUNTESTFLAGS); \
+	  done; \
+	else echo "WARNING: could not find \`runtest'" 1>&2; :;\
+	fi
+site.exp: Makefile
+	@echo 'Making a new site.exp file...'
+	@echo '## these variables are automatically generated by make ##' >site.tmp
+	@echo '# Do not edit here.  If you wish to override these values' >>site.tmp
+	@echo '# edit the last section' >>site.tmp
+	@echo 'set srcdir $(srcdir)' >>site.tmp
+	@echo "set objdir `pwd`" >>site.tmp
+	@echo 'set build_alias "$(build_alias)"' >>site.tmp
+	@echo 'set build_triplet $(build_triplet)' >>site.tmp
+	@echo 'set host_alias "$(host_alias)"' >>site.tmp
+	@echo 'set host_triplet $(host_triplet)' >>site.tmp
+	@echo 'set target_alias "$(target_alias)"' >>site.tmp
+	@echo 'set target_triplet $(target_triplet)' >>site.tmp
+	@echo '## All variables above are generated by configure. Do Not Edit ##' >>site.tmp
+	@test ! -f site.exp || \
+	  sed '1,/^## All variables above are.*##/ d' site.exp >> site.tmp
+	@-rm -f site.bak
+	@test ! -f site.exp || mv site.exp site.bak
+	@mv site.tmp site.exp
+
+distclean-DEJAGNU:
+	-rm -f site.exp site.bak
+	-l='$(DEJATOOL)'; for tool in $$l; do \
+	  rm -f $$tool.sum $$tool.log; \
+	done
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkdir_p) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+	$(MAKE) $(AM_MAKEFLAGS) check-DEJAGNU
+check: check-am
+all-am: Makefile
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-DEJAGNU distclean-generic \
+	distclean-libtool
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am
+
+.PHONY: all all-am check check-DEJAGNU check-am clean clean-generic \
+	clean-libtool distclean distclean-DEJAGNU distclean-generic \
+	distclean-libtool distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-exec \
+	install-exec-am install-info install-info-am install-man \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+	uninstall uninstall-am uninstall-info-am
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/config/default.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/config/default.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/config/default.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/config/default.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,3 @@
+load_lib standard.exp
+load_lib libmudflap.exp
+load_lib mfconfig.exp

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/libmudflap.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/libmudflap.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/libmudflap.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/libmudflap.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,287 @@
+# Copyright (C) 2001, 2002, 2003, 2004 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 2 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 this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
+
+# Define libmudflap callbacks for dg.exp.
+# This file is a copy of libstdc++-v3's dejagnu driver, with minor changes.
+
+# Useful hook:  if ${hostname}_init exists, it will be called, almost
+# the last thing before testing begins.  This can be defined in, e.g.,
+# ~/.dejagnurc or $DEJAGNU.
+
+proc load_gcc_lib { filename } {
+    global srcdir
+    load_file $srcdir/../../gcc/testsuite/lib/$filename
+}
+
+load_lib mfdg.exp
+load_lib libgloss.exp
+load_gcc_lib target-libpath.exp
+
+proc libmudflap-init { language } {
+    global env
+    global srcdir outdir blddir objdir tool_root_dir
+    global cxx cxxflags
+    global includes
+    global libs
+    global gluefile wrap_flags
+    global ld_library_path
+
+    switch $language {
+        "c" { set cxx [find_gcc] }
+        "c++" { set cxx [find_g++] }
+        default { error "bad language code $language"; return }
+    }
+
+    verbose -log "libmudflap-init $cxx"
+
+    set blddir [lookfor_file [get_multilibs] libmudflap]
+    set cxxblddir [lookfor_file [get_multilibs] libstdc++-v3]
+    set cxxflags_file "${cxxblddir}/scripts/testsuite_flags"
+
+    # By default, we assume we want to run program images.
+    global dg-do-what-default
+    set dg-do-what-default run
+
+    # set LD_LIBRARY_PATH so that libgcc_s, libstdc++ binaries can be found.
+    # locate libgcc.a so we don't need to account for different values of
+    # SHLIB_EXT on different platforms
+    set gccdir [lookfor_file $tool_root_dir gcc/libgcc.a]
+    if {$gccdir != ""} {
+	set gccdir [file dirname $gccdir]
+    }
+
+    set ld_library_path "."
+    append ld_library_path ":${gccdir}"
+    append ld_library_path ":${cxxblddir}/src/.libs"
+    if {[is_remote host] == 0} {
+	foreach i "[exec ${gccdir}/xgcc --print-multi-lib]" {
+	    set mldir ""
+	    regexp -- "\[a-z0-9=_/\.-\]*;" $i mldir
+	    set mldir [string trimright $mldir "\;@"]
+	    if { "$mldir" == "." } {
+		continue
+	    }
+	    if { [llength [glob -nocomplain ${gccdir}/${mldir}/libgcc_s*.so.*]] >= 1 } {
+		append ld_library_path ":${gccdir}/${mldir}"
+	    }
+	}
+    }
+    append ld_library_path ":${blddir}/.libs"
+
+    set libs "-L${blddir}/.libs"
+    set cxxflags "-ggdb3 -DDEBUG_ASSERT"
+    set includes "-I${srcdir} -I${srcdir}/.. -I.."
+
+    if {$language == "c++"} {
+        if {[file exists $cxxflags_file]} then {
+            set includes "${includes} [exec sh $cxxflags_file --build-includes]"
+            set cxxflags "${cxxflags} [exec sh $cxxflags_file --cxxflags]"
+            # c++ libs are included by --build-cxx below
+            set cxx "[exec sh $cxxflags_file --build-cxx]"
+        } else {
+            lappend libs "-L${cxxblddir}src/.libs"
+            lappend includes "-I../../libstdc++-v3/include"
+        }
+    }
+
+    global mfconfig_libs
+    global add_flags
+    append add_flags " $mfconfig_libs"
+
+    set_ld_library_path_env_vars
+    if [info exists env(LD_LIBRARY_PATH)] {
+	verbose -log "LD_LIBRARY_PATH = $env(LD_LIBRARY_PATH)"
+    }
+
+    if { [target_info needs_status_wrapper]!=""} {
+      file delete ${objdir}/testglue.o;
+      set gluefile ${objdir}/testglue.o;
+      set result [build_wrapper $gluefile];
+      if { $result != "" } {
+          set gluefile [lindex $result 0];
+          set wrap_flags [lindex $result 1];
+      } else {
+          unset gluefile
+      }
+    }
+
+    # If there is no static library then don't run tests with -static.
+    global tool
+    set opts "additional_flags=-static"
+    lappend opts "additional_flags=-fmudflap"
+    lappend opts "additional_flags=-lmudflap"
+    set src stlm[pid].c
+    set exe stlm[pid].x
+
+    set f [open $src "w"]
+    puts $f "int main () { }"
+    close $f
+    set lines [${tool}_target_compile $src $exe executable "$opts"]
+    file delete $src
+    remote_file build delete $exe
+
+    if { ![string match "" $lines] } {
+	# Compilation failed; assume static library is not available.
+	global MUDFLAP_FLAGS
+	set i [lsearch $MUDFLAP_FLAGS "*static*"]
+	set MUDFLAP_FLAGS [lreplace $MUDFLAP_FLAGS $i $i]
+    }
+}
+
+proc libmudflap-dg-test { prog do_what extra_tool_flags } {
+    # Set up the compiler flags, based on what we're going to do.
+
+    switch $do_what {
+	"preprocess" {
+	    set compile_type "preprocess"
+	    set output_file "[file rootname [file tail $prog]].i"
+	}
+	"compile" {
+	    set compile_type "assembly"
+	    set output_file "[file rootname [file tail $prog]].s"
+	}
+	"assemble" {
+	    set compile_type "object"
+	    set output_file "[file rootname [file tail $prog]].o"
+	}
+	"link" {
+	    set compile_type "executable"
+	    set output_file "./[file rootname [file tail $prog]].exe"
+	}
+	"run" {
+	    set compile_type "executable"
+	    # FIXME: "./" is to cope with "." not being in $PATH.
+	    # Should this be handled elsewhere?
+	    # YES.
+	    set output_file "./[file rootname [file tail $prog]].exe"
+	    # This is the only place where we care if an executable was
+	    # created or not.  If it was, dg.exp will try to run it.
+	    remote_file build delete $output_file;
+	}
+	default {
+	    perror "$do_what: not a valid dg-do keyword"
+	    return ""
+	}
+    }
+    set options ""
+    if { $extra_tool_flags != "" } {
+	lappend options "additional_flags=$extra_tool_flags"
+    }
+
+    global mfconfig_libs
+    lappend options "libs=$mfconfig_libs"
+
+    set comp_output [libmudflap_target_compile "$prog" "$output_file" "$compile_type" $options];
+    set comp_output [prune_gcc_output $comp_output ];
+
+    return [list $comp_output $output_file]
+}
+
+
+proc libmudflap_target_compile { source dest type options } {
+    global gluefile 
+    global wrap_flags
+    global cxx
+    global cxxflags
+    global includes
+    global libs
+    global blddir
+
+    if { [target_info needs_status_wrapper] != "" && [info exists gluefile] } {
+	lappend options "libs=${gluefile}"
+	lappend options "ldflags=${wrap_flags}"
+    }
+
+    set cxx_final $cxx
+    set cxxlibglossflags  [libgloss_link_flags]
+    set cxx_final [concat $cxx_final $cxxlibglossflags]
+    set cxx_final [concat $cxx_final $cxxflags]
+    set cxx_final [concat $cxx_final $includes]
+    set cxx_final [concat $cxx_final $libs]
+
+    lappend options "compiler=$cxx_final"
+
+    # Picks up the freshly-built testsuite library corresponding to the
+    # multilib under test.
+    lappend options "ldflags=-L${blddir}/testsuite"
+
+    return [target_compile $source $dest $type $options]
+}
+
+
+# A bit sloppy...  Returns a list of source files (full pathnames) to
+# compile.  We mimic the mkcheck script in that the first time this is run,
+# all existing files are listed in "testsuite_files" in the output
+# directory.  Subsequent runs pull the list from that file, allowing users
+# to trim the list down to problematic tests.
+### This is supposed to be done via RUNTESTFLAGS, but that doesn't work.
+proc libmudflap-list-sourcefiles { } {
+    global srcdir
+    global outdir
+
+    set files_file "${outdir}/testsuite_files"
+    set sfiles ""
+    if { [file exists $files_file] } {
+	set f [open $files_file]
+	while { ! [eof $f] } {
+	    set t [gets $f]
+	    if { [string length "$t"] != 0 } {
+		lappend sfiles ${srcdir}/${t}
+	    }
+	}
+    } else {
+	set f [open $files_file "w"]
+	set where_we_were [pwd]
+	cd $srcdir
+	foreach s [lsort [glob -nocomplain "*/*.cc" "*/*/*.cc" "{,*/}*/*/*/*.cc" ]] {
+	    lappend sfiles ${srcdir}/${s}
+	    puts $f $s
+	}
+	cd $where_we_were
+    }
+    close $f
+
+    # Disable wchar_t tests if library not configured to support
+    # wchar_t testing. 
+    set wchar_file "${outdir}/testsuite_wchar_t"    
+    if { [file exists $wchar_file] } {
+	return $sfiles
+    } else {
+	# Remove wchar_t tests files from list.
+	set res {}
+	foreach w $sfiles {
+	    if [regexp "wchar_t" $w] {
+		verbose -log "element out list is $w"
+	    } else {
+		verbose -log "element in list is $w"
+		lappend res $w
+	    }
+	}
+	return $res
+    }
+}
+
+
+proc prune_gcc_output { text } {
+    regsub -all {(^|\n)[^\n]*ld: warning: libgcc_s[^\n]*not found[^\n]*try using[^\n]*} $text "" text
+    regsub -all {(^|\n)[^\n]*In function.*pthread_create[^\n]*} $text "" text
+    regsub -all {(^|\n)[^\n]*the use of .pthread.*is deprecated[^\n]*} $text "" text
+    regsub -all {(^|\n)[^\n]*Dwarf Error:.*FORM value: 14[^\n]*} $text "" text
+    regsub -all {(^|\n)[^\n]*In function[^\n]*} $text "" text
+    regsub -all {(^|\n)[^\n]*Using.*in statically linked applications requires[^\n]*} $text "" text
+
+    return $text
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/mfdg.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/mfdg.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/mfdg.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/lib/mfdg.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,377 @@
+# `mfdg' - overrides parts of general purpose testcase driver.
+# Copyright (C) 1994 - 2001, 2003 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 2 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 this program; if not, write to the Free Software
+# Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+
+# This is a modified excerpt of dejagnu/lib/dg.exp.
+
+load_lib dg.exp
+
+
+# dg-test -- runs a new style DejaGnu test
+#
+# Syntax: dg-test [-keep-output] prog tool_flags default_extra_tool_flags
+#
+# PROG is the full path name of the file to pass to the tool (eg: compiler).
+# TOOL_FLAGS is a set of options to always pass.
+# DEFAULT_EXTRA_TOOL_FLAGS are additional options if the testcase has none.
+
+#proc dg-test { prog tool_flags default_extra_tool_flags } {
+proc dg-test { args } {
+    global dg-do-what-default dg-interpreter-batch-mode dg-linenum-format
+    global errorCode errorInfo
+    global tool
+    global srcdir		;# eg: /calvin/dje/build/gcc/./testsuite/
+    global host_triplet target_triplet
+
+    set keep 0
+    set i 0
+    set dg-repetitions 1 ;# may be overridden by { dg-repetitions N }
+    global dg-timeout
+    set dg-timeout 0 ;# likewise by { dg-timeout N }
+
+    if { [string index [lindex $args 0] 0] == "-" } {
+	for { set i 0 } { $i < [llength $args] } { incr i } {
+	    if { [lindex $args $i] == "--" } {
+		incr i
+		break
+	    } elseif { [lindex $args $i] == "-keep-output" } {
+		set keep 1
+	    } elseif { [string index [lindex $args $i] 0] == "-" } {
+		clone_output "ERROR: dg-test: illegal argument: [lindex $args $i]"
+		return
+	    } else {
+		break
+	    }
+	}
+    }
+
+    if { $i + 3 != [llength $args] } {
+	clone_output "ERROR: dg-test: missing arguments in call"
+	return
+    }
+    set prog [lindex $args $i]
+    set tool_flags [lindex $args [expr $i + 1]]
+    set default_extra_tool_flags [lindex $args [expr $i + 2]]
+
+    set text "\[- A-Za-z0-9\.\;\"\_\:\'\`\(\)\!\#\=\+\?\&\*]*"
+
+    set name [dg-trim-dirname $srcdir $prog]
+    # If we couldn't rip $srcdir out of `prog' then just do the best we can.
+    # The point is to reduce the unnecessary noise in the logs.  Don't strip
+    # out too much because different testcases with the same name can confuse
+    # `test-tool'.
+    if [string match "/*" $name] {
+	set name "[file tail [file dirname $prog]]/[file tail $prog]"
+    }
+
+    if {$tool_flags != ""} {
+	append name " ($tool_flags)"
+    }
+
+    # Process any embedded dg options in the testcase.
+
+    # Use "" for the second element of dg-do-what so we can tell if it's been
+    # explicitly set to "S".
+    set dg-do-what [list ${dg-do-what-default} "" P]
+    set dg-excess-errors-flag 0
+    set dg-messages ""
+    set dg-extra-tool-flags $default_extra_tool_flags
+    set dg-final-code ""
+
+    # `dg-output-text' is a list of two elements: pass/fail and text.
+    # Leave second element off for now (indicates "don't perform test")
+    set dg-output-text "P"
+
+    # Define our own "special function" `unknown' so we catch spelling errors.
+    # But first rename the existing one so we can restore it afterwards.
+    catch {rename dg-save-unknown ""}
+    rename unknown dg-save-unknown
+    proc unknown { args } {
+	return -code error "unknown dg option: $args"
+    }
+
+    set tmp [dg-get-options $prog]
+    foreach op $tmp {
+	verbose "Processing option: $op" 3
+	set status [catch "$op" errmsg]
+	if { $status != 0 } {
+	    if { 0 && [info exists errorInfo] } {
+		# This also prints a backtrace which will just confuse
+		# testcase writers, so it's disabled.
+		perror "$name: $errorInfo\n"
+	    } else {
+		perror "$name: $errmsg for \"$op\"\n"
+	    }
+	    # ??? The call to unresolved here is necessary to clear `errcnt'.
+	    # What we really need is a proc like perror that doesn't set errcnt.
+	    # It should also set exit_status to 1.
+	    unresolved "$name: $errmsg for \"$op\""
+	    return
+	}
+    }
+
+    # Restore normal error handling.
+    rename unknown ""
+    rename dg-save-unknown unknown
+
+    # If we're not supposed to try this test on this target, we're done.
+    if { [lindex ${dg-do-what} 1] == "N" } {
+	unsupported "$name"
+	verbose "$name not supported on this target, skipping it" 3
+	return
+    }
+
+    # Run the tool and analyze the results.
+    # The result of ${tool}-dg-test is in a bit of flux.
+    # Currently it is the name of the output file (or "" if none).
+    # If we need more than this it will grow into a list of things.
+    # No intention is made (at this point) to preserve upward compatibility
+    # (though at some point we'll have to).
+
+    set results [${tool}-dg-test $prog [lindex ${dg-do-what} 0] "$tool_flags ${dg-extra-tool-flags}"];
+
+    set comp_output [lindex $results 0];
+    set output_file [lindex $results 1];
+
+    #send_user "\nold_dejagnu.exp: comp_output1 = :$comp_output:\n\n"
+    #send_user "\nold_dejagnu.exp: message = :$message:\n\n"
+    #send_user "\nold_dejagnu.exp: message length = [llength $message]\n\n"
+
+    foreach i ${dg-messages} {
+	verbose "Scanning for message: $i" 4
+
+	# Remove all error messages for the line [lindex $i 0]
+	# in the source file.  If we find any, success!
+	set line [lindex $i 0]
+	set pattern [lindex $i 2]
+	set comment [lindex $i 3]
+	#send_user "Before:\n$comp_output\n"
+	if [regsub -all "(^|\n)(\[^\n\]+$line\[^\n\]*($pattern)\[^\n\]*\n?)+" $comp_output "\n" comp_output] {
+            set comp_output [string trimleft $comp_output]
+	    set ok pass
+	    set uhoh fail
+	} else {
+	    set ok fail
+	    set uhoh pass
+	}
+	#send_user "After:\n$comp_output\n"
+
+	# $line will either be a formatted line number or a number all by
+	# itself.  Delete the formatting.
+	scan $line ${dg-linenum-format} line
+	switch [lindex $i 1] {
+	    "ERROR" {
+		$ok "$name $comment (test for errors, line $line)"
+	    }
+	    "XERROR" {
+		x$ok "$name $comment (test for errors, line $line)"
+	    }
+	    "WARNING" {
+		$ok "$name $comment (test for warnings, line $line)"
+	    }
+	    "XWARNING" {
+		x$ok "$name $comment (test for warnings, line $line)"
+	    }
+	    "BOGUS" {
+		$uhoh "$name $comment (test for bogus messages, line $line)"
+	    }
+	    "XBOGUS" {
+		x$uhoh "$name $comment (test for bogus messages, line $line)"
+	    }
+	    "BUILD" {
+		$uhoh "$name $comment (test for build failure, line $line)"
+	    }
+	    "XBUILD" {
+		x$uhoh "$name $comment (test for build failure, line $line)"
+	    }
+	    "EXEC" { }
+	    "XEXEC" { }
+	}
+	#send_user "\nold_dejagnu.exp: comp_output2= :$comp_output:\n\n"
+    }
+    #send_user "\nold_dejagnu.exp: comp_output3 = :$comp_output:\n\n"
+
+    # Remove messages from the tool that we can ignore.
+    #send_user "comp_output: $comp_output\n"
+    set comp_output [prune_warnings $comp_output]
+
+    if { [info proc ${tool}-dg-prune] != "" } {
+	set comp_output [${tool}-dg-prune $target_triplet $comp_output]
+	switch -glob $comp_output {
+	    "::untested::*" {
+		regsub "::untested::" $comp_output "" message
+		untested "$name: $message"
+		return
+	    }
+	    "::unresolved::*" {
+		regsub "::unresolved::" $comp_output "" message
+		unresolved "$name: $message"
+		return
+	    }
+	    "::unsupported::*" {
+		regsub "::unsupported::" $comp_output "" message
+		unsupported "$name: $message"
+		return
+	    }
+	}
+    }
+
+    # See if someone forgot to delete the extra lines.
+    regsub -all "\n+" $comp_output "\n" comp_output
+    regsub "^\n+" $comp_output "" comp_output
+    #send_user "comp_output: $comp_output\n"
+
+    # Don't do this if we're testing an interpreter.
+    # FIXME: why?
+    if { ${dg-interpreter-batch-mode} == 0 } {
+	# Catch excess errors (new bugs or incomplete testcases).
+	if ${dg-excess-errors-flag} {
+	    setup_xfail "*-*-*"
+	}
+	if ![string match "" $comp_output] {
+	    fail "$name (test for excess errors)"
+	    send_log "Excess errors:\n$comp_output\n"
+	} else {
+	    pass "$name (test for excess errors)"
+	}
+    }
+
+    # Run the executable image if asked to do so.
+    # FIXME: This is the only place where we assume a standard meaning to
+    # the `keyword' argument of dg-do.  This could be cleaned up.
+    if { [lindex ${dg-do-what} 0] == "run" } {
+	if ![file exists $output_file] {
+	    warning "$name compilation failed to produce executable"
+	} else {
+	    set testname $name
+	    for {set rep 0} {$rep < ${dg-repetitions}} {incr rep} {
+		# include repetition number in test name
+		if {$rep > 0} { set name "$testname (rerun $rep)" }
+
+		set status -1
+		set result [${tool}_load $output_file]
+		set status [lindex $result 0];
+		set output [lindex $result 1];
+		#send_user "After exec, status: $status\n"
+
+		if { "$status" == "pass" } {
+		    verbose "Exec succeeded." 3
+		} elseif { "$status" == "fail" } {
+		    # It would be nice to get some info out of errorCode.
+		    if [info exists errorCode] {
+			verbose "Exec failed, errorCode: $errorCode" 3
+		    } else {
+			verbose "Exec failed, errorCode not defined!" 3
+		    }
+		}
+		
+		if { [lindex ${dg-do-what} 2] == "F" } {
+		    # Instead of modelling this as an xfail (via setup_xfail), 
+		    # treat an expected crash as a success.
+		    if { $status == "pass" } then { set status fail } else { set status pass }
+		    set testtype "crash"
+		} else { set testtype "execution" }
+		
+		$status "$name $testtype test"
+		
+		if { [llength ${dg-output-text}] > 1 } {
+		    #send_user "${dg-output-text}\n"
+		    if { [lindex ${dg-output-text} 0] == "F" } {
+			setup_xfail "*-*-*"
+		    }
+		    set texttmp [lindex ${dg-output-text} 1]
+		    if { ![regexp $texttmp ${output}] } {
+			fail "$name output pattern test"
+		    } else {
+			pass "$name output pattern test"
+		    }
+		    verbose -log "Output pattern $texttmp"
+		    unset texttmp
+		}
+	    }
+	}
+    }
+
+    # Are there any further tests to perform?
+    # Note that if the program has special run-time requirements, running
+    # of the program can be delayed until here.  Ditto for other situations.
+    # It would be a bit cumbersome though.
+
+    if ![string match ${dg-final-code} ""] {
+	regsub -all "\\\\(\[{}\])" ${dg-final-code} "\\1" dg-final-code
+	# Note that the use of `args' here makes this a varargs proc.
+	proc dg-final-proc { args } ${dg-final-code}
+	verbose "Running dg-final tests." 3
+	verbose "dg-final-proc:\n[info body dg-final-proc]" 4
+	if [catch "dg-final-proc $prog" errmsg] {
+	    perror "$name: error executing dg-final: $errmsg"
+	    # ??? The call to unresolved here is necessary to clear `errcnt'.
+	    # What we really need is a proc like perror that doesn't set errcnt.
+	    # It should also set exit_status to 1.
+	    unresolved "$name: error executing dg-final: $errmsg"
+	}
+    }
+
+    # Do some final clean up.
+    # When testing an interpreter, we don't compile something and leave an
+    # output file.
+    if { ! ${keep} && ${dg-interpreter-batch-mode} == 0 } {
+	catch "exec rm -f $output_file"
+    }
+}
+
+
+
+# 
+# Indicate that this test case is to be rerun several times.  This
+# is useful if it is nondeterministic.  This applies to rerunning the
+# test program only, not rebuilding it.
+# The embedded format is "{ dg-repetitions N }", where N is the number
+# of repetitions.  It better be greater than zero.
+#
+proc dg-repetitions { line value } {
+    upvar dg-repetitions repetitions
+    set repetitions $value
+}
+
+
+# 
+# Indicate that this test case is to be run with a short timeout.
+# The embedded format is "{ dg-timeout N }", where N is in seconds.
+#
+proc dg-timeout { line value } {
+    global dg-timeout
+    set dg-timeout $value
+}
+
+
+# dejagnu's config/unix.exp hard-codes 300 seconds as the timeout
+# for any natively run executable.  That's too long for tests run
+# multiple times and that may possibly hang.  So we override it here
+# to provide some degree of control.
+rename standard_wait hooked_standard_wait
+proc standard_wait { dest timeout } {
+    global dg-timeout
+    if {[info exists dg-timeout]} {
+	if {${dg-timeout} > 0} {
+	    verbose -log "Overriding timeout = ${dg-timeout}"
+	    set timeout ${dg-timeout}
+	}
+    }
+
+    hooked_standard_wait $dest $timeout
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/c++frags.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/c%2B%2Bfrags.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/c++frags.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/c++frags.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,22 @@
+global MUDFLAP_FLAGS
+set MUDFLAP_FLAGS [list {} {-static} { -O} {-O2} {-O3}]
+
+libmudflap-init c++
+if {$cxx == "g++"} then {
+    unsupported "g++ not found"
+    return
+}
+
+dg-init
+
+global srcdir
+
+foreach flags $MUDFLAP_FLAGS {
+    foreach srcfile [lsort [glob -nocomplain ${srcdir}/libmudflap.c++/*frag.cxx]] {
+	set bsrc [file tail $srcfile]
+	setenv MUDFLAP_OPTIONS "-viol-segv"
+	dg-runtest $srcfile $flags "-fmudflap -lmudflap"
+    }
+}
+
+dg-finish

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors-1.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/ctors-1.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors-1.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors-1.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,20 @@
+#include <iostream>
+
+
+extern char k [];
+
+class foo
+{
+ public:
+  foo (char *m) { m [40] = 20; }
+};
+
+
+foo f1 (k);
+foo f2 (k);
+foo f3 (k);
+
+int main ()
+{
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors-2.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/ctors-2.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors-2.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors-2.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1 @@
+char k [500];

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/ctors.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/ctors.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,48 @@
+global MUDFLAP_FLAGS
+set MUDFLAP_FLAGS [list {} {-static} {-O2} {-O3}]
+
+libmudflap-init c++
+if {$cxx == "g++"} then {
+    unsupported "g++ not found"
+    return
+}
+
+dg-init
+
+global srcdir subdir
+
+foreach flags $MUDFLAP_FLAGS {
+    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 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}"
+    if [string match "" $l2]  { pass $test } { fail $test }
+
+    set l3 [libmudflap_target_compile "ctors-1.o ctors-2.o" "ctors-12.exe" executable {additional_flags=-fmudflap additional_flags=-lmudflap additional_flags=-lstdc++}]
+    set test "ctors-12 linkage ${flags}"
+    if [string match "" $l3]  { pass $test } { fail $test }
+
+    set l4 [libmudflap_target_compile "ctors-2.o ctors-1.o" "ctors-21.exe" executable {additional_flags=-fmudflap additional_flags=-lmudflap additional_flags=-lstdc++}]
+    set test "ctors-21 linkage ${flags}"
+    if [string match "" $l3]  { pass $test } { fail $test }
+
+    setenv MUDFLAP_OPTIONS "-viol-segv"
+
+    remote_spawn host "./ctors-12.exe"
+    set l5 [remote_wait host 10]
+    set test "ctors-12 execution ${flags}"
+    if {[lindex $l5 0] == 0}  { pass $test } { fail $test }
+
+    remote_spawn host "./ctors-21.exe"
+    set l6 [remote_wait host 10]
+    set test "ctors-21 execution ${flags}"
+    if {[lindex $l6 0] == 0}  { pass $test } { fail $test }
+
+    foreach f [glob -nocomplain "ctors-*"] {
+       remote_file build delete $f
+    }
+}
+
+dg-finish

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/error1-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/error1-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/error1-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/error1-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,5 @@
+// PR 26789
+// { dg-do compile }
+
+struct A;
+A a; // { dg-error "incomplete" }

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/error2-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/error2-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/error2-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/error2-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,10 @@
+// PR 26790
+// { dg-do compile }
+
+struct A;
+
+A foo()  // { dg-error "incomplete" }
+{
+    A a; // { dg-error "incomplete" }
+    return a;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/fail24-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/fail24-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/fail24-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/fail24-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char zoo [10];
+
+int main ()
+{
+int i = strlen ("twelve") + strlen ("zero") + strlen ("seventeen");
+zoo[i] = 'a';
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*zoo.*static.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass27-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/pass27-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass27-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass27-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,12 @@
+class foo {
+  char z [10];
+public:
+  char *get_z () { return & this->z[0]; }
+};
+
+int main ()
+{
+foo x;
+x.get_z()[9] = 'a';
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass28-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/pass28-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass28-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass28-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,20 @@
+class foo {
+  char z [10];
+public:
+  virtual char *get_z () { return & this->z[0]; }
+};
+
+class bar: public foo {
+  char q [20];
+public:
+  char *get_z () { return & this->q[0]; }
+};
+
+int main () {
+foo *x = new bar ();
+
+x->get_z()[9] = 'a';
+
+delete x;
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass31-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/pass31-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass31-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass31-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char zoo [10];
+
+int main ()
+{
+int i = strlen ("eight") + strlen ("one");
+zoo[i] = 'a';
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass41-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/pass41-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass41-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass41-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,10 @@
+#include <string>
+#include <iostream>
+
+int
+main (int argc, char *argv[])
+{
+    std::string myStr = "Hello, World!";
+    std::cout << myStr << std::endl;
+    return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass55-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/pass55-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass55-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass55-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,7 @@
+#include <vector>
+
+int main() {
+  std::vector<int> v;
+  v.push_back(1);
+  return 0;
+} 

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass57-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/pass57-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass57-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass57-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,25 @@
+#include <vector>
+#include <string>
+
+class fitscolumn
+  {
+  private:
+    std::string name_, unit_;
+   int i, t;
+  public:
+    fitscolumn (const std::string &nm, const std::string &un,int i1,int t1)
+      : name_(nm), unit_(un), i(i1), t(t1){}
+  };
+
+void init_bintab(std::vector<fitscolumn> & columns_)
+{
+  char ttype[81], tunit[81], tform[81];
+  long repc;
+  int typecode;
+  columns_.push_back (fitscolumn (ttype,tunit,1,typecode));
+}
+
+int main ()
+{
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass58-frag.cxx
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c%2B%2B/pass58-frag.cxx?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass58-frag.cxx (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c++/pass58-frag.cxx Thu Nov  8 16:56:19 2007
@@ -0,0 +1,12 @@
+// PR 19319
+struct k {
+  int data;
+  k(int j): data(j) {}
+};
+k make_k () { return k(1); }
+
+int main ()
+{
+  k foo = make_k ();
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/cfrags.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/cfrags.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/cfrags.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/cfrags.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,21 @@
+global MUDFLAP_FLAGS
+set MUDFLAP_FLAGS [list {} {-static} {-O2} {-O3}]
+
+libmudflap-init c
+
+dg-init
+
+global srcdir
+foreach flags $MUDFLAP_FLAGS {
+    foreach srcfile [lsort [glob -nocomplain \
+                            ${srcdir}/libmudflap.c/*frag.c \
+                            ${srcdir}/libmudflap.c/heap*.c \
+                            ${srcdir}/libmudflap.c/hook*.c \
+                            ${srcdir}/libmudflap.c/pass*.c]] {
+	set bsrc [file tail $srcfile]
+	setenv MUDFLAP_OPTIONS "-viol-segv"
+	dg-runtest $srcfile $flags "-fmudflap -lmudflap"
+    }
+}
+
+dg-finish

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-1.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-1.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-1.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-1.c Thu Nov  8 16:56:19 2007
@@ -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;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-2.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-2.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-2.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs-2.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,2 @@
+typedef struct { char *name; } dummy;
+dummy d[] = { {"a"}, {0} };

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/externs.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,43 @@
+global MUDFLAP_FLAGS
+set MUDFLAP_FLAGS [list {} {-static} {-O2} {-O3}]
+
+libmudflap-init c
+dg-init
+
+global srcdir subdir
+
+foreach flags $MUDFLAP_FLAGS {
+    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

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail1-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail1-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail1-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail1-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+volatile int foo [10];
+foo[10] = 0;
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. foo.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail10-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail10-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail10-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail10-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+volatile int foo[10];
+int sz = sizeof (int);
+
+volatile char *bar = (char *)foo;
+bar [sz * 10] = 0;
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. foo.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail11-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail11-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail11-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail11-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int i = 10;
+char *x = (char *) malloc (i * sizeof (char));
+
+while (i--)
+{
+  ++x;
+  *x = 0;
+}
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail12-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail12-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail12-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail12-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int i = 10;
+int *x = (int *) malloc (i * sizeof (int));
+
+while (i--)
+{
+  ++x;
+  *x = 0;
+}
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail13-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail13-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail13-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail13-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct a {
+  int x;
+  int y;
+  char z;
+};
+
+struct b {
+  int x;
+  int y;
+};
+
+struct b k;
+
+(*((volatile struct a *) &k)).z = 'q';
+
+return 0;
+}
+/* { dg-output "mudflap violation 1..check/write.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. k.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail14-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail14-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail14-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail14-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct a {
+  int x;
+  int y;
+  char z;
+};
+
+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 *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail15-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail15-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail15-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail15-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct base {
+  int basic;
+}; 
+
+struct derived { 
+  struct base common;
+  char extra;
+};
+
+volatile struct base b;
+volatile struct base *bp;
+
+bp = (struct base *)&b;
+
+bp->basic = 10;
+((struct derived volatile *)bp)->extra = 'x';
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. b.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail16-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail16-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail16-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail16-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct base {
+  int basic;
+}; 
+
+struct derived { 
+  struct base common;
+  char extra;
+};
+
+struct base *bp;
+
+bp = (struct base *) malloc (sizeof (struct base));;
+
+bp->basic = 10;
+((struct derived *)bp)->extra = 'x';
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail17-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail17-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail17-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail17-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+
+char * x;
+int foo;
+x = (char *) malloc (10);
+strcpy (x, "123456789");
+foo = strlen (x+10);
+x [foo] = 1; /* we just just use foo to force execution of strlen */
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail18-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail18-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail18-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail18-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+/* One cannot redeclare __mf_lc_mask in proper C from instrumented
+   code, because of the way the instrumentation code emits its decls.  */
+extern unsigned foo __asm__ ("__mf_lc_mask");
+unsigned * volatile bar = &foo;
+*bar = 4;
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.__mf_lc_mask.*no-access.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail19-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail19-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail19-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail19-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct foo {
+  int bar [10];
+};
+
+struct foo *k = (struct foo *) malloc (2 * sizeof(int));
+k->bar[5] = 9;
+free (k);
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail2-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail2-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail2-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail2-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+volatile int foo [10][10];
+foo[10][0] = 0;
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. foo.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail20-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail20-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail20-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail20-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+volatile char *p = (char *) 0;
+*p = 5;
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.NULL.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail21-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail21-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail21-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail21-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+ int *bar = (int *) malloc (sizeof (int));
+/* Make an access here to get &foo into the lookup cache.  */
+*bar = 5;
+__mf_watch (bar, sizeof(int));
+/* This access should trigger the watch violation.  */
+*bar = 10;
+/* NOTREACHED */
+return 0;
+}
+/* { dg-output "mudflap violation 1.*watch.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail22-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail22-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail22-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail22-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct boo { int a; };
+int c;
+struct boo *b = malloc (sizeof (struct boo));
+__mf_set_options ("-check-initialization");
+c = b->a;
+(void) malloc (c); /* some dummy use of c */
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.malloc region.*1r/0w.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail23-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail23-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail23-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail23-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char zoo [10];
+
+int main ()
+{
+int i = strlen ("012345") + strlen ("6789") + strlen ("01"); /* 11 */
+zoo[i] = 'a';
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*zoo.*static.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail25-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail25-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail25-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail25-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+__mf_set_options ("-check-initialization");
+foo = (char *)malloc (10);
+bar = (char *)malloc (10);
+/* bar[2] = 'z'; */ /* don't touch memcpy source */
+memcpy(foo+1, bar+1, 9);
+return 0;
+}
+/* { dg-output "mudflap violation 1.*check.read.*memcpy source.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*malloc region.*alloc time.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail26-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail26-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail26-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail26-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+
+__mf_set_options ("-check-initialization");
+foo = (char *)malloc (1);
+
+/* These two operations each expand to a read-modify-write.
+ * Even though the end result is that every bit of foo[0] is
+ * eventually written to deterministically, the first read
+ * triggers an uninit error.  Ideally, it shouldn't, so this
+ * should be treated more like a regular XFAIL.  */
+foo[0] &= 0xfe;
+foo[0] |= 0x01;
+
+return foo[0];
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*malloc region.*1r/0w.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail27-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail27-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail27-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail27-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char volatile *
+__attribute__((noinline))
+foo (unsigned i)
+{
+  char volatile buffer[10];
+  char volatile *k = i ? & buffer[i] : NULL; /* defeat addr-of-local-returned warning */
+  return k;
+}
+
+int main ()
+{
+char volatile *f = foo (5);
+f[0] = 'b';
+
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*buffer.*alloc.*dealloc" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail28-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail28-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail28-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail28-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int foo (int *u, int i)
+{
+   return u[i];  /* this dereference should be instrumented */
+}
+
+int main ()
+{
+int *k = malloc (6);
+return foo (k, 8);
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*malloc region.*alloc" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail29-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail29-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail29-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail29-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int foo (int u[10])
+{
+   return u[8];  /* this dereference should be instrumented */
+}
+
+int main ()
+{
+int *k = malloc (6);
+return foo (k);
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*malloc region.*alloc" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail3-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail3-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail3-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail3-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+volatile int foo [10][10][10];
+foo[9][10][0] = 0;
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. foo.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail30-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail30-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail30-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail30-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int foo (int u)
+{
+   return u*u;
+}
+
+int main ()
+{
+int *k = malloc(5);
+int j = foo (k[8]);  /* this call argument should be instrumented */
+return j;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*malloc region.*alloc" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail31-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail31-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail31-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail31-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+extern int h (int i, int j);
+
+int main ()
+{
+  int z = h (4, 10);
+  return 0;
+}
+
+int h (int i, int j)
+{
+  int k[i];
+  k[j] = i;
+  return j;
+}
+
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*\(h\).*k" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail32-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail32-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail32-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail32-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+void foo (int k)
+{
+  volatile int *b = & k;
+  b++;
+  *b = 5;
+}
+
+int main ()
+{
+  foo (5);
+  return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*k" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail33-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail33-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail33-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail33-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,25 @@
+#include <stdlib.h>
+
+#define SIZE 16
+
+char b[SIZE];
+char a[SIZE];
+
+int main ()
+{
+  int i, j=0, k;
+  int a_before_b = (& a[0] < & b[0]);
+  /* Rather than iterating linearly, which would allow loop unrolling
+     and mapping to pointer manipulation, we traverse the "joined"
+     arrays in some random order.  */
+  for (i=0; i<SIZE*2; i++)
+    {
+      k = rand() % (SIZE*2);
+      j += (a_before_b ? a[k] : b[k]);
+    }
+  return j;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*\[ab\]" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail34-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail34-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail34-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail34-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,22 @@
+#include <stdlib.h>
+
+struct s
+{
+  int a1[4];
+};
+
+struct s a, b;
+int idx = 7; /* should pass to the next object */
+
+int
+main ()
+{
+  int i, j=0;
+  int a_before_b = (& a < & b);
+  j = (a_before_b ? a.a1[idx] : b.a1[idx]);
+  return j;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*\[ab\]" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail35-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail35-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail35-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail35-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,23 @@
+#include <stdlib.h>
+
+struct k
+{
+  int p;
+  struct {
+    int m;
+  } 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
+     COMPONENT_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 *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail36-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail36-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail36-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail36-frag.c Thu Nov  8 16:56:19 2007
@@ -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 *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail37-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail37-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail37-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail37-frag.c Thu Nov  8 16:56:19 2007
@@ -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 *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail38-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail38-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail38-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail38-frag.c Thu Nov  8 16:56:19 2007
@@ -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 *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail39-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail39-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail39-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail39-frag.c Thu Nov  8 16:56:19 2007
@@ -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 *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail4-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail4-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail4-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail4-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char foo [10];
+strcpy(foo, "1234567890");
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. foo.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail40-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail40-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail40-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail40-frag.c Thu Nov  8 16:56:19 2007
@@ -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 *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail5-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail5-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail5-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail5-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char foo [15];
+char bar [10];
+memcpy(foo, bar, 11);
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*.main. bar.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail6-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail6-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail6-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail6-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+foo = (char *)malloc (10);
+bar = (char *)malloc (15);
+
+memcpy(foo, bar, 11);
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail7-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail7-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail7-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail7-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+foo = (char *)malloc (12);
+bar = (char *)malloc (10);
+
+memcpy(foo+1, bar+1, 10);
+return 0;
+}
+/* { dg-output "mudflap violation 1.*" } */
+/* { dg-output "Nearby object 1.*" } */
+/* { dg-output "mudflap object.*malloc region.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail8-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail8-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail8-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail8-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+foo = (char *)malloc (10);
+bar = (char *)malloc (10);
+
+free(bar);
+
+memcpy(foo, bar, 10);
+return 0;
+}
+/* { dg-output "mudflap violation 1.*memcpy source.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*malloc region.*alloc time.*dealloc time.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail9-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail9-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail9-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/fail9-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+foo = (char *)malloc (10);
+bar = (char *)malloc (10);
+
+free(foo);
+
+bar[4] = 'a'; /* touch source buffer */
+memcpy(foo, bar, 10);
+return 0;
+}
+
+/* { dg-output "mudflap violation 1.*memcpy dest.*" } */
+/* { dg-output "Nearby object.*" } */
+/* { dg-output "mudflap object.*malloc region.*alloc time.*dealloc time.*" } */
+/* { dg-do run { xfail *-*-* } } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/heap-scalestress.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/heap-scalestress.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/heap-scalestress.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/heap-scalestress.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,79 @@
+/* zz30
+ *
+ * demonstrate a splay-tree depth problem
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#ifndef SCALE
+#define SCALE 100000
+#endif
+
+
+struct list
+{
+  struct list *next;
+};
+
+
+int
+main ()
+{
+  struct list *head = NULL;
+  struct list *tail = NULL;
+  struct list *p;
+  long n;
+  int direction;
+
+  for (direction = 0; direction < 2; direction++)
+    {
+      fprintf (stdout, "allocating\n");
+      fflush (stdout);
+
+      for (n = 0; n < SCALE; ++n)
+	{
+	  p = malloc (sizeof *p);
+	  if (NULL == p)
+	    {
+	      fprintf (stdout, "malloc failed\n");
+	      break;
+	    }
+	  if (direction == 0)
+	    {			/* add at tail */
+	      p->next = NULL;
+	      if (NULL != tail)
+		tail->next = p;
+	      else
+		head = p;
+	      tail = p;
+	    }
+	  else
+	    {			/* add at head */
+	      p->next = head;
+	      if (NULL == tail)
+		tail = p;
+	      head = p;
+	    }
+	}
+
+      fprintf (stdout, "freeing\n");
+      fflush (stdout);
+
+      while (NULL != head)
+	{
+	  p = head;
+	  head = head->next;
+	  free (p);
+	}
+
+    }
+
+  fprintf (stdout, "done\n");
+  fflush (stdout);
+
+  return (0);
+}
+
+/* { dg-output "allocating.*freeing.*allocating.*freeing.*done" } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook-allocstuff.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook-allocstuff.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook-allocstuff.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook-allocstuff.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main ()
+{
+  char *foo = (char *) malloc (10);
+  strcpy (foo, "hello");
+  foo = (char *) realloc (foo, 20);
+  printf ("%s", foo);
+  if (strcmp (foo, "hello"))
+    abort ();
+  free (foo);
+  printf (" world\n");
+  return 0;
+}
+/* { dg-output "hello world" } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook2-allocstuff.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook2-allocstuff.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook2-allocstuff.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/hook2-allocstuff.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,9 @@
+/* Generates recursive malloc call on i386-freebsd4.10 with -fmudflap.  */
+#include <stdlib.h>
+
+int
+main (void)
+{
+  char *p = malloc (1<<24);
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass-stratcliff.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass-stratcliff.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass-stratcliff.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass-stratcliff.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,319 @@
+/* Test for string function add boundaries of usable memory.
+   Copyright (C) 1996,1997,1999,2000,2001,2002 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper at cygnus.com>, 1996.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301 USA.  */
+
+#define _GNU_SOURCE 1
+#define __USE_GNU
+
+/* Make sure we don't test the optimized inline functions if we want to
+   test the real implementation.  */
+#undef __USE_STRING_INLINES
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/param.h>
+
+#ifndef MAX
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#endif
+
+int
+main (int argc, char *argv[])
+{
+  int size = sysconf (_SC_PAGESIZE);
+  char *adr, *dest;
+  int result = 0;
+
+  adr = (char *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
+		       MAP_PRIVATE | MAP_ANON, -1, 0);
+  dest = (char *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
+			MAP_PRIVATE | MAP_ANON, -1, 0);
+  if (adr == MAP_FAILED || dest == MAP_FAILED)
+    {
+      if (errno == ENOSYS)
+        puts ("No test, mmap not available.");
+      else
+        {
+          printf ("mmap failed: %m");
+          result = 1;
+        }
+    }
+  else
+    {
+      int inner, middle, outer;
+
+      mprotect(adr, size, PROT_NONE);
+      mprotect(adr + 2 * size, size, PROT_NONE);
+      adr += size;
+
+      mprotect(dest, size, PROT_NONE);
+      mprotect(dest + 2 * size, size, PROT_NONE);
+      dest += size;
+
+      memset (adr, 'T', size);
+
+      /* strlen test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+          for (inner = MAX (outer, size - 64); inner < size; ++inner)
+	    {
+	      adr[inner] = '\0';
+
+	      if (strlen (&adr[outer]) != (size_t) (inner - outer))
+		{
+		  printf ("strlen flunked for outer = %d, inner = %d\n",
+			  outer, inner);
+		  result = 1;
+		}
+
+	      adr[inner] = 'T';
+	    }
+        }
+
+      /* strchr test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+	  for (middle = MAX (outer, size - 64); middle < size; ++middle)
+	    {
+	      for (inner = middle; inner < size; ++inner)
+		{
+		  char *cp;
+		  adr[middle] = 'V';
+		  adr[inner] = '\0';
+
+		  cp = strchr (&adr[outer], 'V');
+
+		  if ((inner == middle && cp != NULL)
+		      || (inner != middle
+			  && (cp - &adr[outer]) != middle - outer))
+		    {
+		      printf ("strchr flunked for outer = %d, middle = %d, "
+			      "inner = %d\n", outer, middle, inner);
+		      result = 1;
+		    }
+
+		  adr[inner] = 'T';
+		  adr[middle] = 'T';
+		}
+	    }
+        }
+
+      /* Special test.  */
+      adr[size - 1] = '\0';
+      if (strchr (&adr[size - 1], '\n') != NULL)
+	{
+	  puts ("strchr flunked for test of empty string at end of page");
+	  result = 1;
+	}
+
+      /* strrchr test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+	  for (middle = MAX (outer, size - 64); middle < size; ++middle)
+	    {
+	      for (inner = middle; inner < size; ++inner)
+		{
+		  char *cp;
+		  adr[middle] = 'V';
+		  adr[inner] = '\0';
+
+		  cp = strrchr (&adr[outer], 'V');
+
+		  if ((inner == middle && cp != NULL)
+		      || (inner != middle
+			  && (cp - &adr[outer]) != middle - outer))
+		    {
+		      printf ("strrchr flunked for outer = %d, middle = %d, "
+			      "inner = %d\n", outer, middle, inner);
+		      result = 1;
+		    }
+
+		  adr[inner] = 'T';
+		  adr[middle] = 'T';
+		}
+	    }
+        }
+
+#ifndef __FreeBSD__
+      /* rawmemchr test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+	  for (middle = MAX (outer, size - 64); middle < size; ++middle)
+	    {
+	      char *cp;
+	      adr[middle] = 'V';
+
+	      cp = (char *) rawmemchr (&adr[outer], 'V');
+
+	      if (cp - &adr[outer] != middle - outer)
+		{
+		  printf ("rawmemchr flunked for outer = %d, middle = %d\n",
+			  outer, middle);
+		  result = 1;
+		}
+
+	      adr[middle] = 'T';
+	    }
+        }
+#endif
+
+      /* strcpy test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+          for (inner = MAX (outer, size - 64); inner < size; ++inner)
+	    {
+	      adr[inner] = '\0';
+
+	      if (strcpy (dest, &adr[outer]) != dest
+		  || strlen (dest) != (size_t) (inner - outer))
+		{
+		  printf ("strcpy flunked for outer = %d, inner = %d\n",
+			  outer, inner);
+		  result = 1;
+		}
+
+	      adr[inner] = 'T';
+	    }
+        }
+
+      /* strncpy tests */
+      adr[size-1] = 'T';
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+	{
+	  size_t len;
+
+	  for (len = 0; len < size - outer; ++len)
+	    {
+	      if (strncpy (dest, &adr[outer], len) != dest
+		  || memcmp (dest, &adr[outer], len) != 0)
+		{
+		  printf ("outer strncpy flunked for outer = %d, len = %Zd\n",
+			  outer, len);
+		  result = 1;
+		}
+	    }
+        }
+      adr[size-1] = '\0';
+
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+          for (inner = MAX (outer, size - 64); inner < size; ++inner)
+	    {
+	      size_t len;
+
+	      adr[inner] = '\0';
+
+	      for (len = 0; len < size - outer + 64; ++len)
+		{
+		  if (strncpy (dest, &adr[outer], len) != dest
+		      || memcmp (dest, &adr[outer],
+				 MIN (inner - outer, len)) != 0
+		      || (inner - outer < len
+			  && strlen (dest) != (inner - outer)))
+		    {
+		      printf ("strncpy flunked for outer = %d, inner = %d, len = %Zd\n",
+			      outer, inner, len);
+		      result = 1;
+		    }
+		  if (strncpy (dest + 1, &adr[outer], len) != dest + 1
+		      || memcmp (dest + 1, &adr[outer],
+				 MIN (inner - outer, len)) != 0
+		      || (inner - outer < len
+			  && strlen (dest + 1) != (inner - outer)))
+		    {
+		      printf ("strncpy+1 flunked for outer = %d, inner = %d, len = %Zd\n",
+			      outer, inner, len);
+		      result = 1;
+		    }
+		}
+
+	      adr[inner] = 'T';
+	    }
+        }
+
+#ifndef __FreeBSD__
+      /* stpcpy test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+          for (inner = MAX (outer, size - 64); inner < size; ++inner)
+	    {
+	      adr[inner] = '\0';
+
+	      if ((stpcpy (dest, &adr[outer]) - dest) != inner - outer)
+		{
+		  printf ("stpcpy flunked for outer = %d, inner = %d\n",
+			  outer, inner);
+		  result = 1;
+		}
+
+	      adr[inner] = 'T';
+	    }
+        }
+
+      /* stpncpy test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+        {
+          for (middle = MAX (outer, size - 64); middle < size; ++middle)
+	    {
+	      adr[middle] = '\0';
+
+	      for (inner = 0; inner < size - outer; ++ inner)
+		{
+		  if ((stpncpy (dest, &adr[outer], inner) - dest)
+		      != MIN (inner, middle - outer))
+		    {
+		      printf ("stpncpy flunked for outer = %d, middle = %d, "
+			      "inner = %d\n", outer, middle, inner);
+		      result = 1;
+		    }
+		}
+
+	      adr[middle] = 'T';
+	    }
+        }
+#endif
+
+      /* memcpy test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+	for (inner = 0; inner < size - outer; ++inner)
+	  if (memcpy (dest, &adr[outer], inner) !=  dest)
+	    {
+	      printf ("memcpy flunked for outer = %d, inner = %d\n",
+		      outer, inner);
+	      result = 1;
+	    }
+
+#ifndef __FreeBSD__
+      /* mempcpy test */
+      for (outer = size - 1; outer >= MAX (0, size - 128); --outer)
+	for (inner = 0; inner < size - outer; ++inner)
+	  if (mempcpy (dest, &adr[outer], inner) !=  dest + inner)
+	    {
+	      printf ("mempcpy flunked for outer = %d, inner = %d\n",
+		      outer, inner);
+	      result = 1;
+	    }
+#endif
+    }
+
+  return result;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass1-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass1-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass1-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass1-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int foo [10];
+foo[9] = 0;
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass10-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass10-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass10-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass10-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int foo[10];
+int sz = sizeof (int);
+
+char *bar = (char *)foo;
+bar [sz * 9] = 0;
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass11-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass11-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass11-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass11-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int i = 10;
+char *x = (char *) malloc (i * sizeof (char));
+
+while (--i)
+{
+  ++x;
+  *x = 0;
+}
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass12-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass12-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass12-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass12-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int i = 10;
+int *x = (int *) malloc (i * sizeof (int));
+
+while (--i)
+{
+  ++x;
+  *x = 0;
+}
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass13-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass13-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass13-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass13-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct a {
+  int x;
+  int y;
+  char z;
+};
+
+struct a k;
+
+k.z = 'q';
+
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass14-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass14-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass14-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass14-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct a {
+  int x;
+  int y;
+  char z;
+};
+
+struct a k;
+struct a *p;
+
+p = &k;
+
+p->z = 'q';
+
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass15-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass15-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass15-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass15-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct base {
+  int basic;
+}; 
+
+struct derived { 
+  struct base common;
+  char extra;
+};
+
+struct derived d;
+struct base *bp;
+
+bp = (struct base *)&d;
+
+bp->basic = 10;
+((struct derived *)bp)->extra = 'x';
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass16-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass16-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass16-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass16-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct base {
+  int basic;
+}; 
+
+struct derived { 
+  struct base common;
+  char extra;
+};
+
+struct base *bp;
+
+bp = (struct base *) malloc (sizeof (struct derived));
+
+bp->basic = 10;
+((struct derived *)bp)->extra = 'x';
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass17-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass17-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass17-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass17-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+
+strlen("123456789");
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass18-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass18-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass18-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass18-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int t;
+char foo[3] = { 'b', 'c', 'd' };
+int bar[3] = {1, 2, 0};
+t = 1;
+
+/* These tests check expression evaluation rules, such as
+   ensuring that side-effect expression (++) get executed the
+   right number of times; that array lookup checks nest correctly. */
+foo[t++] = 'a';
+if (foo[0] != 'b' || foo[1] != 'a' || foo[2] != 'd' || t != 2) abort ();
+if (bar[0] != 1 || bar[1] != 2 || bar[2] != 0) abort();
+
+foo[bar[t--]] = 'e';
+if (foo[0] != 'e' || foo[1] != 'a' || foo[2] != 'd' || t != 1) abort ();
+if (bar[0] != 1 || bar[1] != 2 || bar[2] != 0) abort();
+
+foo[bar[++t]--] = 'g';
+if (foo[0] != 'g' || foo[1] != 'a' || foo[2] != 'd' || t != 2) abort ();
+if (bar[0] != 1 || bar[1] != 2 || bar[2] != -1) abort();
+
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass19-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass19-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass19-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass19-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct foo {int base; char variable[1]; }; /* a common idiom for variable-size structs */
+
+struct foo * b = (struct foo *) malloc (sizeof (int)); /* enough for base */
+b->base = 4;
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass2-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass2-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass2-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass2-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int foo [10][10];
+foo[9][0] = 0;
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass20-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass20-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass20-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass20-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct bar {int stuff; int array[10]; };
+
+struct bar *foo = (struct bar *) malloc (sizeof (struct bar));
+foo->array[5] = 4;
+free (foo);
+
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass21-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass21-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass21-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass21-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef __FreeBSD__
+#include <alloca.h>
+#endif
+int main ()
+{
+char *boo, *foo;
+boo = (char *) alloca (100);
+boo[99] = 'a';
+foo = (char *) __builtin_alloca (200);
+foo[44] = 'b';
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass22-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass22-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass22-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass22-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct foo {
+  unsigned base:8;
+  unsigned flag1:1;
+  unsigned flag2:3;
+  unsigned flag3:4;
+  char nothing[0];
+};
+
+#define offsetof(TYPE, MEMBER)	((size_t) &((TYPE *) 0)->MEMBER)
+
+struct foo* f = (struct foo *) malloc (offsetof (struct foo, nothing));
+f->base = 1;
+f->flag1 = 1;
+free (f);
+
+
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass23-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass23-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass23-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass23-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct foo {
+  int part1: 8;
+  int nothing : 1;
+  int part2 : 5;
+  int lots_more_nothing : 3;
+  int some_padding; /* for 64-bit hosts */
+  float some_more_nothing;
+  double yet_more_nothing;
+};
+
+#define offsetof(TYPE, MEMBER)	((size_t) &((TYPE *) 0)->MEMBER)
+
+struct foo* q = (struct foo *) malloc (offsetof (struct foo, some_more_nothing));
+q->nothing = 1; /* touch q */ 
+/* The RHS of the following expression is meant to trigger a
+   fold-const.c mapping the expression to a BIT_FIELD_REF.  It glues
+   together the accesses to the two non-neighbouring bitfields into a
+   single bigger boolean test. */
+q->lots_more_nothing = (q->part1 == 13 && q->part2 == 7);
+free (q);
+
+
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass24-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass24-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass24-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass24-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct foo {
+  int zoo;
+  int bar [10];
+  float baz;
+};
+
+#define offsetof(S,F) ((size_t) & (((S *) 0)->F))
+
+struct foo *k = (struct foo *) malloc (offsetof (struct foo, bar[4]));
+k->bar[1] = 9;
+free (k);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass25-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass25-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass25-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass25-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int *foo = malloc (10 * sizeof(int));
+int *bar = & foo[3];
+/* Watching occurs at the object granularity, which is in this case
+   the entire array.  */
+__mf_watch (& foo[1], sizeof(foo[1]));
+__mf_unwatch (& foo[6], sizeof(foo[6]));
+*bar = 10;
+free (foo); 
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass26-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass26-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass26-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass26-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+volatile int *p;
+
+__mf_set_options ("-wipe-stack -no-check-initialization");
+
+{
+  volatile int array [10];
+  p = & array[0];
+
+  array[0] = 2;
+  array[9] = 5;
+
+  /* Array[] should be wiped clean at this point.  */
+}
+
+__mf_set_options ("-no-wipe-stack");
+
+{ 
+  volatile int array2[10];
+
+ /* hope that this is allocated on top of old array[] */  
+  if (p != & array2[0])
+    exit (0);  /* Test is not applicable. */
+
+  array2[5] = 6;
+
+  /* Old values shouldn't still be around; the new one should.  */
+  if (p[0] == 2 || p[9] == 5 || p[5] != 6)
+    abort() ;
+
+  /* array2[] should not be wiped at this point! */
+}
+
+{ 
+  volatile int array3[10];
+
+ /* hope that this is allocated on top of old array[] and array2[]*/  
+  if (p != & array3[0])
+    exit (0);  /* Test is not applicable. */
+
+  array3[1] = 2;
+
+  /* Check that old assignment is still around.  */
+  if (p[5] != 6 || p[1] != 2)
+    abort() ;
+}
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass29-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass29-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass29-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass29-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+struct boo { int a; };
+int c;
+struct boo *b = malloc (sizeof (struct boo));
+__mf_set_options ("-check-initialization");
+b->a = 0;
+/* That __mf_set_options call could be here instead. */
+c = b->a;
+(void) malloc (c); /* some dummy use of c */
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass3-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass3-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass3-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass3-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+int foo [10][10][10];
+foo[9][9][0] = 0;
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass30-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass30-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass30-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass30-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char zoo [10];
+
+int main ()
+{
+int i = strlen ("eight") + strlen ("one");
+zoo[i] = 'a';
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass32-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass32-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass32-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass32-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct foo { char z[10]; };
+
+char * get_z (struct foo *this)
+{
+  return & this->z[0] /* the `this' pointer is not dereferenced! */;
+}
+
+int main ()
+{
+struct foo k;
+char *n = get_z (& k);
+srand ((int)(__mf_uintptr_t) n); /* use the pointer value */
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass33-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass33-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass33-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass33-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test (int *k)
+{
+  if (*k > 5) { *k --; }
+}
+
+int main ()
+{
+int z;
+/* z is initialized, but not via a pointer, so not instrumented */
+z = rand (); 
+test (& z);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass34-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass34-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass34-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass34-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void test (int *k)
+{
+  if (*k > 5) { *k --; }
+}
+
+int z;
+
+int main ()
+{
+/* z is initialized, but not via a pointer, so not instrumented */
+z = rand (); 
+test (& z);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass35-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass35-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass35-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass35-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern char end [];   /* Any old symbol we're sure will be defined. */
+/* { dg-warning "cannot track unknown size extern" "cannot track unknown size extern" { target *-*-* } 0 } */
+
+int main ()
+{
+/* dummy register */
+__mf_register ((void *) end, 1, __MF_TYPE_GUESS, "end");
+char z = end[0];
+return z & 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass36-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass36-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass36-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass36-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+int main ()
+{
+char *k;
+__mf_set_options ("-sigusr1-report -print-leaks");
+k = (char *) malloc (100);
+raise (SIGUSR1);
+free (k);
+return 0;
+}
+/* { dg-output "Leaked object.*name=.malloc region.*objects: 1" } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass38-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass38-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass38-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass38-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,9 @@
+/* Test an odd construct for compilability.  */
+static void *fwd;
+void *bwd = &fwd;
+static void *fwd = &bwd;
+
+int main ()
+{
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass4-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass4-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass4-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass4-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char foo[10];
+strcpy (foo, "123456789");
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass42-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass42-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass42-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass42-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+void
+foo ()
+{
+  putc ('h', stdout);
+  putc ('i', stdout);
+  putc ('\n', stdout);
+}
+
+int
+main (int argc, char *argv[])
+{
+  foo ();
+  return 0;
+}
+/* { dg-output "hi" } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass43-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass43-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass43-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass43-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,11 @@
+void
+foo ()
+{
+}
+
+int
+main (int argc, char *argv[])
+{
+  foo ();
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass44-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass44-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass44-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass44-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+void
+foo ()
+{
+  return; /* accept value-less return statement */
+}
+
+int
+main (int argc, char *argv[])
+{
+  foo ();
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass45-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass45-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass45-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass45-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern void h (const char *p, const char *f);
+int
+main (void)
+{
+  h (0, "foo");
+  return 0;
+}
+
+void
+h (const char *p, const char *f)
+{
+  size_t pl = p == NULL ? 0 : strlen (p);
+  size_t fl = strlen (f) + 1;
+  char a[pl + 1 + fl];
+  char *cp = a;
+  char b[pl + 5 + fl * 2];
+  char *cccp = b;
+  if (p != NULL)
+    {
+      cp = memcpy (cp, p, pl);
+      *cp++ = ':';
+    }
+  memcpy (cp, f, fl);
+  strcpy (b, a);
+  puts (a);
+}
+/* { dg-output "foo" } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass46-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass46-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass46-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass46-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int foo (int *u, int i)
+{
+   return u[i];  /* this dereference should not be instrumented */
+}
+
+int main ()
+{
+  int *k = malloc (6);
+ int l = foo (k, 8);
+ int boo [8];
+ int m = boo [l % 2 + 12]; /* should not be instrumented */
+ return m & strlen (""); /* a fancy way of saying "0" */
+}
+/* { dg-options "-fmudflap -fmudflapir -lmudflap -Wall" } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass47-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass47-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass47-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass47-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,10 @@
+#include <stdlib.h>
+#include <ctype.h>
+
+int main ()
+{
+  char* buf = "hello"; 
+  return ! ((toupper (buf[0]) == 'H' && toupper ('z') == 'Z' &&
+             tolower (buf[4]) == 'o' && tolower ('X') == 'x' &&
+             isdigit (buf[3])) == 0 && isalnum ('4'));
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass48-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass48-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass48-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass48-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,11 @@
+void foo (int k)
+{
+  volatile int *b = & k;
+  *b = 5;
+}
+
+int main ()
+{
+  foo (5);
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass49-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass49-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass49-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass49-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,35 @@
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+int foo (int a, ...)
+{
+  va_list args;
+  char *a1;
+  int a2;
+  int k;
+
+  va_start (args, a);
+  for (k = 0; k < a; k++)
+    {
+      if ((k % 2) == 0)
+        {
+          char *b = va_arg (args, char *);
+          printf ("%s", b);
+        }
+      else
+        {
+          int b = va_arg (args, int);
+          printf ("%d", b);
+        }
+    }
+  va_end (args);
+  return a;
+}
+
+int main ()
+{
+  foo (7, "hello ", 5, " ", 3, " world ", 9, "\n");
+  return 0;
+}
+/* { dg-output "hello 5 3 world 9" } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass5-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass5-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass5-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass5-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char foo [10];
+char bar [10];
+bar[4] = 'k'; /* touch memcpy source */
+memcpy(foo, bar, 10);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass50-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass50-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass50-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass50-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,29 @@
+#include <stdlib.h>
+
+struct a
+{
+  int a1[5];
+  union
+  {
+    int b1[5];
+    struct
+    {
+      int c1;
+      int c2;
+    } b2[4];
+  } a2[8];
+};
+
+int i1 = 5;
+int i2 = 2;
+int i3 = 6;
+int i4 = 0;
+
+int
+main ()
+{
+  volatile struct a *k = calloc (1, sizeof (struct a));
+  k->a2[i1].b1[i2] = k->a2[i3].b2[i4].c2;
+  free ((void *) k);
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass51-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass51-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass51-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass51-frag.c Thu Nov  8 16:56:19 2007
@@ -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;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass52-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass52-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass52-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass52-frag.c Thu Nov  8 16:56:19 2007
@@ -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;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass53-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass53-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass53-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass53-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,41 @@
+int foo1 ()
+{
+  union { int l; char c[sizeof (int)]; } k1;
+  char *m;
+  k1.l = 0;
+  /* This test variant triggers ADDR_EXPR of k explicitly in order to
+     ensure it's registered with the runtime.  */
+  m = k1.c;
+  k1.c [sizeof (int)-1] = m[sizeof (int)-2];
+}
+
+int foo2 ()
+{
+  union { int l; char c[sizeof (int)]; } k2;
+  k2.l = 0;
+  /* Since this access is known-in-range, k need not be registered
+     with the runtime, but then this access better not be instrumented
+     either.  */
+  k2.c [sizeof (int)-1] ++;
+  return k2.l;
+}
+
+int foo3idx = sizeof (int)-1;
+
+int foo3 ()
+{
+  union { int l; char c[sizeof (int)]; } k3;
+  k3.l = 0;
+  /* NB this test uses foo3idx, an extern variable, to defeat mudflap
+     known-in-range-index optimizations.  */
+  k3.c [foo3idx] ++;
+  return k3.l;
+}
+
+int main ()
+{
+  foo1 ();
+  foo2 ();
+  foo3 ();
+  return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass54-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass54-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass54-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass54-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,33 @@
+struct k 
+{
+  struct {
+    int b;
+    int c;
+  } a;
+};
+
+static struct k l;
+static struct k m;
+
+void foo ()
+{
+  /* This should not be instrumented. */ 
+  l.a.b = 5;
+}
+
+void bar ()
+{
+  /* This should not be instrumented. */ 
+  m.a.b = 5;
+}
+
+int main ()
+{
+  /* Force TREE_ADDRESSABLE on "l" only.  */
+  volatile int *k = & l.a.c;
+  *k = 8;
+  __mf_set_options ("-mode-violate");
+  foo ();
+  bar ();
+  __mf_set_options ("-mode-check");
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass56-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass56-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass56-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass56-frag.c Thu Nov  8 16:56:19 2007
@@ -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;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass6-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass6-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass6-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass6-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+
+foo = (char *)malloc (10);
+bar = (char *)malloc (10);
+bar[2] = 'z'; /* touch memcpy source */
+memcpy(foo, bar, 10);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass7-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass7-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass7-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass7-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+foo = (char *)malloc (10);
+bar = (char *)malloc (10);
+bar[2] = 'z'; /* touch memcpy source */
+memcpy(foo+1, bar+1, 9);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass8-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass8-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass8-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass8-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+foo = (char *)malloc (10);
+bar = (char *)malloc (10);
+
+free(bar);
+bar = (char *)malloc (10);
+bar[6] = 'k'; /* touch memcpy source */
+memcpy(foo, bar, 10);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass9-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass9-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass9-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.c/pass9-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main ()
+{
+char *foo;
+char *bar;
+foo = (char *)malloc (10);
+bar = (char *)malloc (10);
+
+free(foo);
+foo = (char *)malloc (10);
+bar[3] = 'w'; /* touch memcpy source */
+memcpy(foo, bar, 10);
+return 0;
+}

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/cthfrags.exp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/cthfrags.exp?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/cthfrags.exp (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/cthfrags.exp Thu Nov  8 16:56:19 2007
@@ -0,0 +1,25 @@
+global MUDFLAP_FLAGS
+set MUDFLAP_FLAGS [list {} {-static -DSTATIC} {-O2} {-O3}]
+
+libmudflap-init c
+
+dg-init
+
+global srcdir
+foreach flags $MUDFLAP_FLAGS {
+    foreach srcfile [lsort [glob -nocomplain ${srcdir}/libmudflap.cth/*.c]] {
+	set bsrc [file tail $srcfile]
+	setenv MUDFLAP_OPTIONS "-viol-segv"
+	if {$libmudflapth} then {
+	    # --noinhibit-exec works around a ld problem that causes
+	    # "Dwarf Error: Invalid or unhandled FORM value: 14"
+	    # to fail builds unnecessarily.
+	    dg-runtest $srcfile $flags "-fmudflapth -lmudflapth -lpthread -Wl,--noinhibit-exec"
+	} else {
+	    if {$flags != ""} {set f " ($flags)"} {set f ""}
+            untested "libmudflap.cth/$bsrc$f"
+	}
+    }
+}
+
+dg-finish

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass37-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass37-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass37-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass37-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,58 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <sched.h>
+
+static void *
+func (void *p)
+{
+  int *counter = (int *) p;
+  unsigned i;
+  
+  for (i=0; i<100; i++)
+    {
+      (*counter) ++;
+      {
+	int array[17];
+	unsigned x = i % (sizeof(array)/sizeof(array[0]));
+	/* VRP could prove that x is within [0,16], but until then, the
+	   following access will ensure that array[] is registered to
+	   libmudflap. */
+	array[x] = i;
+      }
+      sched_yield (); /* sleep (1); */
+    }
+
+  return (NULL);
+}
+
+
+int main ()
+{
+  int rc;
+  unsigned i;
+  enum foo { NT=10 };
+  pthread_t threads[NT];
+  int counts[NT];
+
+
+  for (i=0; i<NT; i++)
+    {
+      counts[i] = 0;
+      rc = pthread_create (& threads[i], NULL, func, (void *) & counts[i]);
+      if (rc) abort();
+    }
+
+  for (i=0; i<NT; i++)
+    {
+      rc = pthread_join (threads[i], NULL);
+      if (rc) abort();      
+      printf ("%d%s", counts[i], (i==NT-1) ? "\n" : " ");
+    }
+
+  return 0;
+}
+
+/* { dg-output "100 100 100 100 100 100 100 100 100 100" } */
+/* { dg-repetitions 20 } */
+/* { dg-timeout 10 } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass39-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass39-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass39-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass39-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,57 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <sched.h>
+#include <assert.h>
+
+static void *
+func (void *p)
+{
+  int *counter = (int *) p;
+  unsigned i;
+  enum { numarrays = 100, numels = 17 };
+  char *arrays [numarrays];
+
+  for (i=0; i<numarrays; i++)
+    {
+      (*counter) ++;
+      unsigned x = i % numels;
+      arrays[i] = calloc (numels, sizeof(arrays[i][0]));
+      assert (arrays[i] != NULL);
+      arrays[i][x] = i;
+      free (arrays[i]);
+      sched_yield (); /* sleep (1); */
+    }
+
+  return (NULL);
+}
+
+
+int main ()
+{
+  int rc;
+  unsigned i;
+  enum foo { NT=10 };
+  pthread_t threads[NT];
+  int counts[NT];
+
+
+  for (i=0; i<NT; i++)
+    {
+      counts[i] = 0;
+      rc = pthread_create (& threads[i], NULL, func, (void *) & counts[i]);
+      if (rc) abort();
+    }
+
+  for (i=0; i<NT; i++)
+    {
+      rc = pthread_join (threads[i], NULL);
+      if (rc) abort();       
+     printf ("%d%s", counts[i], (i==NT-1) ? "\n" : " ");
+    }
+
+  return 0;
+}
+/* { dg-output "100 100 100 100 100 100 100 100 100 100" } */
+/* { dg-repetitions 20 } */
+/* { dg-timeout 10 } */

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass40-frag.c
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass40-frag.c?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass40-frag.c (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/libmudflap.cth/pass40-frag.c Thu Nov  8 16:56:19 2007
@@ -0,0 +1,59 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+
+static void *
+func (void *p)  
+{
+        return (NULL);
+}               
+
+static void
+test (void)
+{
+        int             rc;
+        pthread_attr_t  my_pthread_attr;
+        pthread_t       h;
+        long            i;
+
+        rc = pthread_attr_init (&my_pthread_attr);
+
+        for (i = 1; i <= 10000; ++i) {
+                if (i%100 == 0) fprintf (stderr, "%i ", i);
+                if (i%1000 == 0) fprintf (stderr, "\n");
+#ifndef STATIC 
+	  /* Some glibc versions don't like static multithreaded programs doing this. */
+                if (i==5000) __mf_set_options ("-thread-stack=192");
+#endif
+                rc = pthread_create (&h, &my_pthread_attr,
+                        func, NULL);
+                if (rc)
+                        break;
+
+                rc = pthread_join (h, NULL);
+                if (rc)
+                        break;
+        }
+        
+        rc = pthread_attr_destroy (&my_pthread_attr);
+}
+                
+int main ()
+{
+        test ();
+                
+        return (0);
+}
+
+/* { dg-timeout 20 } */
+/* { dg-output "100 200 300 400 500 600 700 800 900 1000 \n" } */
+/* { dg-output "1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 \n" } */
+/* { dg-output "2100 2200 2300 2400 2500 2600 2700 2800 2900 3000 \n" } */
+/* { dg-output "3100 3200 3300 3400 3500 3600 3700 3800 3900 4000 \n" } */
+/* { dg-output "4100 4200 4300 4400 4500 4600 4700 4800 4900 5000 \n" } */
+/* { dg-output "5100 5200 5300 5400 5500 5600 5700 5800 5900 6000 \n" } */
+/* { dg-output "6100 6200 6300 6400 6500 6600 6700 6800 6900 7000 \n" } */
+/* { dg-output "7100 7200 7300 7400 7500 7600 7700 7800 7900 8000 \n" } */
+/* { dg-output "8100 8200 8300 8400 8500 8600 8700 8800 8900 9000 \n" } */
+/* { dg-output "9100 9200 9300 9400 9500 9600 9700 9800 9900 10000 \n" } */
+

Added: llvm-gcc-4.2/trunk/libmudflap/testsuite/mfconfig.exp.in
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libmudflap/testsuite/mfconfig.exp.in?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libmudflap/testsuite/mfconfig.exp.in (added)
+++ llvm-gcc-4.2/trunk/libmudflap/testsuite/mfconfig.exp.in Thu Nov  8 16:56:19 2007
@@ -0,0 +1,4 @@
+global mfconfig_libs
+set mfconfig_libs "@LIBS@"
+global libmudflapth
+set libmudflapth "@build_libmudflapth@"

Added: llvm-gcc-4.2/trunk/libobjc/ChangeLog
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/ChangeLog?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/ChangeLog (added)
+++ llvm-gcc-4.2/trunk/libobjc/ChangeLog Thu Nov  8 16:56:19 2007
@@ -0,0 +1,1268 @@
+2007-05-13  Release Manager
+
+	* GCC 4.2.0 released.
+
+2006-10-14  Geoffrey Keating  <geoffk at apple.com>
+
+	* Makefile.in: Use multi_basedir instead of toplevel_srcdir.
+	* configure.ac: Use multi.m4 from aclocal rather than custom
+	code.  Use multi_basedir instead of toplevel_srcdir.
+	* aclocal.m4: Regenerate.
+	* configure: Regenerate.
+
+2006-10-10  Brooks Moses  <bmoses at stanford.edu>
+
+	* Makefile.in: Added empty "pdf" target.
+
+2006-07-18  Paolo Bonzini  <bonzini at gnu.org>
+
+	* configure: Regenerate.
+
+2006-05-23  Carlos O'Donell  <carlos at codesourcery.com>
+
+	* Makefile.in: Add install-html target. Add install-html to .PHONY
+
+2006-02-21  Rainer Orth  <ro at TechFak.Uni-Bielefeld.DE>
+
+	PR libobjc/26309
+	* thr-objc.c (_XOPEN_SOURCE): Don't define on Tru64 UNIX.
+
+2006-01-24  David Ayers  <d.ayers at inode.at>
+
+	PR libobjc/9751
+	* gc.c (class_ivar_set_gcinvisible): Replace strncpy with memcpy
+	and insure the new strings are '\0' termintated.
+
+2006-01-24  David Ayers  <d.ayers at inode.at>
+
+	PR libobjc/13946
+	* configure.ac: Add include directives for --enable-objc-gc.
+	* Makefile.in: Ditto.
+	* configure: Regenerate.
+
+	* gc.c (__objc_class_structure_encoding): Increment the used bytes
+	instead of the local pointer to them.
+
+2005-12-14  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR objc/25360
+	* objc/objc-api.c (_C_COMPLEX): New define.
+	* encoding.c (objc_sizeof_type): Handle _C_Complex.
+	(objc_alignof_type): Likewise.
+	(objc_skip_typespec): Likewise.
+
+2005-12-15  David Ayers  <d.ayers at inode.at>
+
+	PR libobjc/14382
+	* README (+load,+initialize): Fix documentation to reflect
+	intended and implemented semantics for +load and +initialize.
+	
+2005-12-12  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* encoding.c (TYPE_FIELDS): Fix to skip over just _C_STRUCT_B and
+	the name.
+	(get_inner_array_type): Fix to skip over _C_ARY_B and size.
+	(rs6000_special_round_type_align): Update for the ABI fix.
+	(objc_layout_finish_structure): Correct the encoding which is passed to
+	ROUND_TYPE_ALIGN.
+
+2005-12-11  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR libobjc/25347
+	* encoding.c (objc_sizeof_type): Don't handle _C_UNION_B special
+	but use the struct layout functions.
+	(objc_alignof_type): Likewise.
+	(objc_layout_structure): Handle _C_UNION_B also.
+	(objc_layout_structure_next_member): Likewise.
+	(objc_layout_finish_structure): Likewise.
+
+2005-12-11  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR libobjc/25346
+	* objc/objc-api.h (_C_BOOL): New define.
+	* encoding.c (objc_sizeof_type): Handle _C_BOOL.
+	(objc_alignof_type): Likewise.
+	(objc_skip_typespec): Likewise.
+
+2005-11-20  David Ayers  <d.ayers at inode.at>
+
+	PR libobjc/19024
+	* objc/hash.h: Remove deprecated hash API.
+	* hash_compat.c: Remove.
+	* Makefile.in: Remove reference to hash_compat.c.
+
+	* configure.ac (VERSION): Bump library version to 2:0:0.
+	* configure: Regenerate.
+
+2005-11-09  Alexandre Oliva  <aoliva at redhat.com>
+
+	PR other/4372
+	* thr-objc.c (_XOPEN_SOURCE): Define.
+
+2005-10-07  Ulrich Weigand  <uweigand at de.ibm.com>
+
+	PR libobjc/23612
+	* objc/objc-api.h (struct objc_ivar): Move definition to
+	global scope.
+
+2005-09-04  Andrew Pinski  <pinskia at physics.uc.edu>
+            Rasmus Hahn  <rassahah at neofonie.de>
+
+	PR libobjc/23108
+	* archive.c (objc_write_type): Correct the element offset.
+	(objc_read_type): Likewise.
+
+2005-08-17  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* All files: Update FSF address.
+
+2005-08-13  Marcin Koziej  <creep at desk.pl>
+            Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR libobjc/22492
+	* exception.c (PERSONALITY_FUNCTION): Fix the PC with finally.
+
+2005-08-13  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* Makefile.in (extra_ldflags_libobjc): New.
+	(libobjc$(libext).la): Add extra_ldflags_libobjc to the link line.
+	(libobjc_gc$(libext).la): Likewise.
+	* configure.ac (extra_ldflags_libgfortran): Set for *-darwin* to
+	"-Wl,-single_module".
+	* configure: Regenerate.
+	* linking.m (_objcInit): Remove.
+
+2005-07-26  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR libobjc/22606
+	* Makefile.in (ALL_CFLAGS): Add -fexceptions.
+
+2005-06-08  David Ayers  <d.ayers at inode.at>
+
+	* objc/NXConstStr.h, objc/Object.h, objc/Protocol.h,
+	objc/encoding.h, objc/hash.h, objc/objc-api.h,
+	objc/runtime.h, objc/sarray.h, objc/thr.h, 
+	objc/typedstream.h: Do not include Objective-C headers as
+	system headers.
+
+2005-06-07  David Ayers  <d.ayers at inode.at>
+
+	* archive.c, init.c, selector.c: Include hash.h.
+	* archive.c, class.c, encoding.c, gc.c, hash.c, hash_compat.c,
+	init.c, misc.c, nil_method.c, objects.c, sarray.c, selector.c,
+	sendmsg.c, thr-dce.c, thr-decosf1.c, thr-irix.c, thr-mach.c,
+	thr-objc.c, thr-os2.c, thr-posix.c, thr-pthreads.c, thr-rtems.c,
+	thr-single.c, thr-solaris.c, thr-vxworks.c, thr-win32.c, thr.c:
+	Include Objective-C headers with quotes and objc/ directory
+	prefix.
+
+2005-05-19  Richard Henderson  <rth at redhat.com>
+
+	* exception.c: Revert last change.
+
+2005-05-19  David Ayers  <d.ayers at inode.at>
+
+	* exception.c: Include tsystem.h for unwind.h.
+
+2005-05-09  Mike Stump  <mrs at apple.com>
+
+	* configure: Regenerate.
+
+2005-04-12  Mike Stump  <mrs at apple.com>
+
+	* configure: Regenerate.
+
+2005-03-21  Zack Weinberg  <zack at codesourcery.com>
+
+	* Makefile.in: Set gcc_version here.
+	* configure.ac: Do not invoke TL_AC_GCC_VERSION.  Adjust quoting
+	in definition of toolexeclibdir so that $(gcc_version) is expanded
+	by the Makefile.
+	* aclocal.m4, configure: Regenerate.
+
+2005-03-03  David Ayers  <d.ayers at inode.at>
+
+	* objc/hash.h (OBJC_IGNORE_DEPRECATED_API): Update deprecated
+	version reference.  Correct typo.
+
+2005-03-02  David Ayers  <d.ayers at inode.at>
+
+	PR libobjc/19024
+	* Makefile.in (OBJS): Add hash_compat.lo.
+	(OBJS_GC): Add hash_compat_gc.lo.
+	(hash_compat_gc.lo): New target and rule.
+	* objc/hash.h (hash_new, hash_delete, hash_add, hash_remove)
+	(hash_next, hash_value_for_key, hash_is_key_in_hash)
+	(hash_ptr, hash_string, compare_ptrs, compare_strings): Prefix
+	with objc_.  Add deprecated non prefixed inlined versions.
+	(OBJC_IGNORE_DEPRECATED_API): New macro to hide deprecated
+	declarations.
+	* hash.c (hash_new, hash_delete, hash_add, hash_remove, hash_next)
+	(hash_value_for_key, hash_is_key_in_hash): Prefix with objc_ and
+	update callers.
+	* hash_compat.c: New file.
+	* archive.c: Update callers.
+	* init.c: Likewise.
+	* selector.c: Likewise.
+	* libobjc.def: Add objc_ versions of hash functions.
+
+2005-02-28  Andrew Pinski <pinskia at physics.uc.edu>
+
+	PR libobjc/20252
+	* Makefile.in (GTHREAD_FLAGS): Remove.
+	(ALL_CFLAGS): Remove usage of GTHREAD_FLAGS.
+	* thr-objc.c: Include config.h.
+	* configure.ac: Instead of looking at GCC's makefile, figure out if
+	GTHREAD_FLAGS should be defined by looking at the `thread model'
+	of the current gcc.
+	* configure: Regenerate.
+	* config.h.in: Regenerate.
+
+2005-02-28  Paolo Bonzini  <bonzini at gnu.org>
+
+	PR bootstrap/17383
+	* configure.ac: Call GCC_TOPLEV_SUBDIRS.
+	(Determine CFLAGS for gthread): Use $host_subdir.
+	* configure: Regenerate.
+	* Makefile.in (host_subdir): New.
+	(INCLUDES): Use it.
+
+2004-12-20  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR libobjc/12035
+	* gc.c: Remove definition of LOGWL, modWORDSZ, and divWORDSZ since
+	they are not used.
+	Include limits.h and stdlib.h.
+	Define BITS_PER_WORD.
+
+2004-12-12  Alexander Malmberg  <alexander at malmberg.org>
+
+	* selector.c (__objc_init_selector_tables): Add missing void to
+	definition.
+
+2004-12-02  Richard Sandiford  <rsandifo at redhat.com>
+
+	* configure.ac: Use TL_AC_GCC_VERSION to set gcc_version.
+	* configure, aclocal.m4: Regenerate.
+
+2004-11-29  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* configure: Regenerate for libtool change.
+
+2004-11-25  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* configure: Regenerate for libtool reversion.
+
+2004-11-24  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* configure: Regenerate for libtool change.
+
+2004-11-24  Kelley Cook  <kcook at gcc.gnu.org>
+
+	* aclocal.m4, config.h.in: Regenerate.
+
+2004-10-08  Mike Stump  <mrs at apple.com>
+	    Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* aclocal.m4: Rename to ...
+	* acinclude.m4: here and also use m4_include instead of sinclude.
+	* aclocal.m4: Regenerate.
+	* configure: Regenerate.
+	* configure.ac: Add AM_MAINTAINER_MODE and AM_PROG_CC_C_O.
+	* Makefile.in (configure): Add @MAINT@ infront of configure.ac
+
+2004-10-08  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* archive.c: Fix all the warnings about passing unsigned char*
+	to char* and the other way too.
+
+2004-09-16  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR libobjc/16448
+	* exception.c: Include config.h
+	(objc_exception_throw): Change _GLIBCXX_SJLJ_EXCEPTIONS to
+	SJLJ_EXCEPTIONS.
+	* configure.ac: Find out what exception handling code we use.
+	* configure: Regenerate.
+	* config.h.in: New file, regenerate.
+
+2004-09-16  Andrew Pinski  <apinski at apple.com>
+
+	* encoding.c (ALTIVEC_VECTOR_MODE): Define a bogus macro.
+
+2004-08-28  Nathanael Nerode  <neroden at gcc.gnu.org>
+
+	* configure.ac: Switch from _GCC_TOPLEV_NONCANONICAL_TARGET to
+	ACX_NONCANONICAL_TARGET.
+	* configure: Regenerate.
+
+2004-08-13  Ziemowit Laski  <zlaski at apple.com>
+
+	* objc/sarray.h: Hoist include of assert.h near the top of file,
+	and mark the remainder of the file 'extern "C"'.
+
+2004-08-13  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* objc/Object.h: Move includes out of extern "C" blocks.
+	* objc/encoding.h: Likewise.
+	* objc/hash.h: Likewise.
+	* objc/objc-api.h: Likewise.
+	* objc/runtime.h: Likewise.
+	* objc/sarray.h: Likewise.
+	* objc/typedstream.h: Likewise.
+
+2004-08-12  Ziemowit Laski  <zlaski at apple.com>
+
+	* objc/NXConstStr.h: Update copyright date; bracket with
+	'extern "C"' for C++ use; make include syntax consistent
+	by using <...> instead of "..."; hoist <objc/...> includes
+	above the 'extern "C"' block.
+	* objc/Object.h: Likewise.
+	* objc/Protocol.h: Likewise.
+	* objc/encoding.h: Likewise.
+	* objc/hash.h: Likewise.
+	* objc/runtime.h: Likewise.
+	* objc/sarray.h: Likewise.
+	* objc/thr.h: Likewise.
+	* objc/typedstream.h: Likewise.
+	* objc/objc-api.h: Add 'extern "C"' block for C++ use.
+	(objc_static_instances): For C++ case, do away with
+	zero-sized array.
+	(objc_method): Hoist definition to file scope.
+	(_objc_load_callback, _objc_object_alloc, class_get_class_method,
+	class_get_instance_method, class_create_instance,
+	class_get_class_name, class_get_instance_size,
+	class_get_meta_class, class_get_super_class, class_get_version,
+	class_is_class, class_is_meta_class, class_set_version,
+	class_get_gc_object_type, class_ivar_set_gcinvisible,
+	get_imp): Rename 'class' parameter to '_class'.
+	* objc/objc-list.h: Add 'extern "C"' block for C++ use.
+	* objc/objc.h: Update copyright date.
+	(arglist_t): Provide a union tag.
+
+2004-07-22  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* thr.c (__objc_thread_detach_function): Do not mark as volatile
+	but instead use the attribute noreturn.
+
+2004-06-28  Zack Weinberg  <zack at codesourcery.com>
+
+	* encoding.c: Rename target_flags with a #define to avoid
+	conflict with a prior declaration.
+
+2004-06-24  Andrew Pinski  <apinski at apple.com>
+
+	* objc/encoding.h: Wrap the functions with extern "C" for C++
+	mode.
+	* objc/hash.h: Likewise.
+	* objc/objc-api.h: Likewise.
+	* objc/objc-list.h: Likewise.
+	* objc/runtime.h: Likewise.
+	* objc/sarray.h: Likewise.
+	* objc/thr.h: Likewise.
+	* objc/typedstream.h: Likewise.
+
+
+2004-06-21  Nick Clifton  <nickc at redhat.com>
+
+	* encoding.c (BITS_PER_UNIT): Define if a definition is not
+	provided.
+
+2004-06-20  Alexander Malmberg  <alexander at malmberg.org>
+
+	* Makefile.in (exception.lo): Remove $(OBJC_GCFLAGS).
+	(exception_gc.lo): New.
+	(OBJS_GC): Add exception_gc.lo.
+
+2004-06-17  Richard Henderson  <rth at redhat.com>
+
+	* exception.c: New file.
+	* Makefile.in (exception.lo): New.
+	(OBJS): Add it.
+
+2004-06-14  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* linking.m (_objcInit): New empty function
+	for Darwin only.
+
+2004-06-11  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* configure.ac: Support --enable-shared=libobjc.
+	* configure: Regenerate.
+
+	PR libobjc/15901
+	* configure.ac: Do not disable shared by default.
+	* configure: Regenerate.
+
+2004-06-03  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* Protocol.m ([-isEqual:]): Small optimizations returning
+	immediately if the argument is equal to self, and accessing
+	the argument's name directly if it's a protocol.
+
+2004-06-03  David Ayers  <d.ayers at inode.at>
+
+	* Protocol.m ([-isEqual:]): Test the class of the argument.
+
+2004-05-25  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* configure.ac (includedir): Rename to ...
+	(includedirname).
+	* Makefile.in: s/includedir/includedirname/.
+
+	PR target/11572
+	* configure.ac (includedir): Set to "include"
+	except for Darwin.
+	(libext) Set to empty except for Darwin.
+	* configure: Regenerate
+	* Makefile.in: s/libobjc.la/libobjc$(libext).la/g.
+	s/include/$(includedir)/g.
+
+2004-05-25  Daniel Jacobowitz  <drow at false.org>
+
+	* Makefile.in: Add .NOEXPORT.
+
+2004-05-25  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	Merge from the libobjc-branch
+	2004-02-09  Andrew Pinski  <pinskia at physics.uc.edu>
+
+		* Makefile.in (OBJC_H): Change objc-deps.h to objc-decls.h.
+
+	2004-02-03  Andrew Pinski  <pinskia at physics.uc.edu>
+
+		* Makefile.in (OBJC_H): Add objc-deps.h.
+
+	2004-01-27  Nicola Pero  <n.pero at mi.flashnet.it>
+
+		* Protocol.m ([-conformsTo:]): If the argument is nil, return NO.
+		([-hash], [-isEqual:]): New methods.
+
+	2004-01-27  Richard Frith-Macdonald <rfm at gnu.org>
+
+		* sarray.c (sarray_free): Add a better comment.
+
+	2004-01-27  Adam Fedor  <fedor at gnu.org>
+
+		* hash.c (hash_add): Cast cachep to int.
+		* selector.c (__sel_register_typed_name): Cast
+		soffset_decode to int.
+
+	2004-01-27  Alexander Malmberg  <alexander at malmberg.org>
+
+		* selector.c: Rename register_selectors_from_list to
+		__objc_register_selectors_from_list. Update caller.
+		(__objc_register_selectors_from_list): Lock __objc_runtime_mutex
+		while registering selectors. Use __sel_register_typed_name instead
+		of sel_register_typed_name. Check for NULL method_name:s.
+		(pool_alloc_selector): New function.
+		(__sel_register_typed_name): Use pool_alloc_selector to allocate
+		selector structures.
+		* sendmsg.c (class_add_method_list): Use
+		__objc_register_selectors_from_list.
+		* objc/runtime.h: Add __objc_register_selectors_from_list.
+
+	2004-01-25  Adam Fedor  <fedor at gnu.org>
+		    Nicola Pero  <n.pero at mi.flashnet.it>
+		    Andrew Pinski  <pinskia at physics.uc.edu>
+
+		* objc/objc-decls.h: New file.
+		* objc/objc-api.h (_objc_lookup_class): Mark as export.
+		(_objc_load_callback): Likewise.
+		(_objc_object_alloc): Likewise.
+		(_objc_object_copy): Likewise.
+		(_objc_object_dispose): Likewise.
+
+	2004-01-25  Andrew Pinski  <pinskia at physics.uc.edu>
+
+		* archive.c: s/__inline__/inline
+		* sendmsg.c: Likewise.
+
+		* encoding.c: Remove FIXME about the warning
+		about unused variable.
+		* sendmsg.c: Add a FIXME comment saying that
+		this should be using libffi.
+
+		* Makefile.in (LIBTOOL): Use @LIBTOOL@ now as it works.
+
+
+2004-05-13  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	* archive.c (objc_read_class): Initialize class_name.
+	(objc_read_selector): Initialize selector_name.
+
+2004-05-09  Richard Sandiford  <rsandifo at redhat.com>
+
+	* Makefile.in (toolexecdir): Remove trailing space.
+
+2004-04-15  Nathanael Nerode  <neroden at gcc.gnu.org>
+
+	PR libobjc/14948
+	* configure.ac: De-precious CC so multilibs work.
+	* configure: Regenerate.
+
+2004-04-14  Nathanael Nerode  <neroden at gcc.gnu.org>
+
+	* configure.ac: Restore toolexecdir.
+	* Makefile.in: Restore toolexecdir.
+	* configure: Regenerate.
+
+2004-04-09  Nathanael Nerode  <neroden at gcc.gnu.org>
+
+	* configure.ac: Remove (unused) glibcpp_prefixdir.
+	* configure: Regenerate.
+
+	* configure.in: Rename to configure.ac.
+	* Makefile.in: Update to match.
+
+	* Makefile.in: Remove toolexecdir, glibcpp_toolexecdir (unused).
+	Replace glibcpp_toolexeclibdir with toolexeclibdir.
+	* configure.in: Remove glibcpp_toolexecdir (unused).
+	Replace glibcpp_toolexeclibdir with toolexeclibdir.  Don't generate
+	config.h or stamp-h (unused).  Move one comment to the right place.
+	* configure: Regenerate.
+	* config.h.in: Remove (unused).
+
+	* config.h.in: Regenerate with autoheader.
+
+	* Makefile.in: Remove (unused) gcc_version_trigger.
+	* configure.in: Remove (unused) glibcpp_builddir.  Don't AC_SUBST
+	gcc_version_trigger.
+	* configure: Regenerate.
+
+	* configure.in: Switch to modern style for AC_INIT, AC_OUTPUT.
+	Sort file into sections.  Remove dnl where appropriate.  Fix
+	other style issues.
+	* configure: Regenerate.
+
+	* configure.in: Replace old AC_PROG_CC hack with new one.
+	Define toplevel_srcdir in terms of srcdir, not top_srcdir (there
+	are no subdirectory output files, so this is fine).  Change prereq
+	to autoconf 2.59.
+	* aclocal.m4: Include ../config/no-executables.m4.
+	* configure: Regenerate with autoconf 2.59.
+
+	* configure.in: Improve comments on gthread_cflags.  Improve m4
+	quotation, and replace 'if test' with 'case', for --enable-objc-gc.
+	* configure: Regenerate.
+
+	* configure.in: Move PACKAGE and VERSION settings up top.  Remove
+	unused call to AC_PROG_LN_S.  Default RANLIB to ':'.  Remove
+	redundant checks for values of RANLIB, AR, INSTALL.
+	* configure: Regenerate.
+
+	* configure.in: Clean up handling of
+	--enable-version-specific-runtime-libs and related variables;
+	replace 'if test' with 'case' where reasonable.  Fix comments.
+	Remove useless libstdcxx_interface.
+	* configure: Regenerate.
+
+	* configure.in: Use _GCC_TOPLEV_NONCANONICAL_TARGET.
+	Replace uses of target_alias with target_noncanonical.
+	* aclocal.m4: Include ../config/acx.m4.
+	* configure: Regenerate.
+	* Makefile.in: Replace uses of target_alias with target_noncanonical.
+	Fix copyright statement.
+
+	* configure.in: Hand-inline bulky, confusing macros from
+	aclocal.m4.  Replace references to "GNU Objective C" with "GCC".
+	Update copyright notice.  Remove stuff for automake, which isn't
+	used in this directory.  Remove emacs local variables.
+	* aclocal.m4: Remove hand-inlined macros.  Update copyright notice.
+	* configure: Regenerate.
+
+2004-03-16  Manfred Hollstein  <mh at suse.com>
+
+	* Makefile.in, configure.in, configure: Update copyright years.
+
+2004-03-15  Manfred Hollstein  <mh at suse.com>
+
+	* Makefile.in (LIBOBJC_VERSION, LIBOBJC_GC_VERSION): Use
+	definition from configure.in.
+	* configure.in (PACKAGE): Add definition.
+	(VERSION): Add definition; substitute it in output files.
+	* configure: Re-generate.
+
+2004-03-05  Ziemowit Laski  <zlaski at apple.com>
+
+	* objc/hash.h (hash_string, compare_strings):
+	Add type-casts to make Objective-C++ happy.
+	* objc/typedstream.h (objc_get_stream_class_version):
+	Rename parameter from 'class' to 'class_name' to make
+	Objective-C++ happy.
+
+2004-03-01  Michael Matz  <matz at suse.de>
+
+	* Makefile.in (ALL_CFLAGS): Add -fno-strict-aliasing.
+
+2004-02-06  Ziemowit Laski  <zlaski at apple.com>
+
+	* objc/objc-api.h (objc_super): The 'class' field shall
+	be named 'super_class' #ifdef __cplusplus.
+
+2004-01-17  Andrew Pinski  <pinskia at physics.uc.edu>
+
+	PR target/10781
+	* encoding.c (rs6000_special_round_type_align): Define.
+
+2004-01-14  Adam Fedor  <fedor at gnu.org>
+
+	PR libobjc/12155
+	* selector.c (__objc_register_instance_methods_to_class): Free
+	new_list if not used.
+
+2004-01-09  Andrew Ruder  <aeruder at ksu.edu>
+
+	PR libobjc/11904
+	* sarray.c (sarray_free): Free array->is_copy_of latter.
+
+2003-12-01  Zack Weinberg  <zack at codesourcery.com>
+
+	PR 11433
+	* Protocol.m (descriptionForInstanceMethod): Don't dereference
+	instance_methods if it's NULL.
+	(descriptionForClassMethod): Likewise for class_methods.
+
+2003-10-24  Rainer Orth  <ro at TechFak.Uni-Bielefeld.DE>
+
+	* Makefile.in (runtime-info.h): Remove -Wp.
+
+2003-10-21  Rainer Orth  <ro at TechFak.Uni-Bielefeld.DE>
+
+	* Makefile.in (CC1OBJ): Remove.
+	(runtime-info.h): Invoke $(CC) so all MULTIFLAGS are handled
+	correctly.
+	Use .m extension for temporary file.
+	Remove assembler temp file.
+
+2003-10-20  Joseph S. Myers  <jsm at polyomino.org.uk>
+
+	* objc/hash.h (hash_string): Don't use a cast as an lvalue.
+
+2003-10-17  Rainer Orth  <ro at TechFak.Uni-Bielefeld.DE>
+
+	* Makefile.in (runtime-info.h): Use MULTIFLAGS.
+
+2003-09-09  Alan Modra  <amodra at bigpond.net.au>
+
+	* configure: Regenerate.
+
+2003-08-27  Alexander Malmberg  <alexander at malmberg.org>
+
+	* Makefile.in, aclocal.m4: Update to $(libdir)/gcc/ instead of
+	(libdir)/gcc-lib/ when installing.
+	* configure: Regenerate.
+
+Thu Jul 10 10:27:43 2003  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	libobjc/9969
+	* sendmsg.c (get_imp): Fixed rare threading problem.
+	(__objc_responds_to): Similar fixes.
+	(objc_msg_lookup): Similar fixes.
+	(__objc_init_install_dtable): Lock the runtime before checking if the
+	table is installed.
+
+2003-05-23  Nathanael Nerode  <neroden at gcc.gnu.org>
+
+	* hash.c, init.c, libobjc.def, libobjc_entry.c, linking.m,
+	makefile.dos, misc.c, nil_method.c, objects.c, sarray.c,
+	selector.c, sendmsg.c, thr-dce.c, thr-decosf1.c, thr-irix.c,
+	thr-mach.c, thr-objc.c, thr-os2.c, thr-posix.c, thr-pthreads.c,
+	thr-rtems.c, thr-single.c, thr-solaris.c, thr-vxworks.c,
+	thr-win32.c, thr.c: Replace "GNU CC" with "GCC".
+	* Makefile.in, NXConstStr.m, Object.m, Protocol.m, archive.c,
+	class.c, encoding.c, gc.c, objc/NXConstStr.h, objc/Object.h,
+	objc/Protocol.h, objc/encoding.h, objc/hash.h, objc/objc-api.h,
+	objc/objc-list.h, objc/objc.h, ocjc/runtime.h, objc/sarray.h,
+	objc/thr.h, objc/typedstream.h: Replace "GNU CC" with "GCC".
+
+Tue May 13 14:56:03 2003  Richard Frith-Macdonald <rfm at gnu.org>
+			  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	libobjc/10742
+	* init.c (class_superclass_of_class): New function.
+	(create_tree_of_subclasses_inherited_from): Use it.
+	(__objc_tree_insert_class): Likewise.
+	(class_is_subclass_of_class): Likewise.
+
+2003-04-11  David Chad  <davidc at freebsd.org>
+	    Loren J. Rittle  <ljrittle at acm.org>
+
+	libobjc/8562
+	* objc/hash.h (hash_string): Constify correctly.
+	(compare_ptrs): Use direct compare.
+	* objc/objc-list.h (list_nth): Rename index to indx to avoid shadow.
+	* objc/sarray.h: Global rename index to indx to avoid shadow.
+
+2003-03-12  Andreas Schwab  <schwab at suse.de>
+
+	* aclocal.m4 (GLIBCPP_EXPORT_INSTALL_INFO): Avoid trailing /. in
+	glibcpp_toolexeclibdir.
+	* configure: Rebuilt.
+
+2003-02-20  Alexandre Oliva  <aoliva at redhat.com>
+
+	* configure.in: Propagate ORIGINAL_LD_FOR_MULTILIBS to
+	config.status.
+	* configure: Rebuilt.
+
+2003-01-27  Alexandre Oliva  <aoliva at redhat.com>
+
+	* aclocal.m4 (glibcpp_toolexeclibdir): Instead of
+	$(MULTISUBDIR), use `$CC -print-multi-os-directory`, unless
+	version_specific_libs is enabled.
+	* configure: Rebuilt.
+
+2003-01-09  Christian Cornelssen  <ccorn at cs.tu-berlin.de>
+
+	* Makefile.in (FLAGS_TO_PASS): Also pass DESTDIR.
+	(install-libs, install-headers): Prepend $(DESTDIR) to
+	destination paths in all (un)installation commands.
+
+2002-12-02  Zack Weinberg  <zack at codesourcery.com>
+
+	* thr-objc.c: Include coretypes.h and tm.h.
+
+2002-12-01  Zack Weinberg  <zack at codesourcery.com>
+
+	* encoding.c, sendmsg.c: Include coretypes.h and tm.h.
+
+2002-11-26  Nathanael Nerode  <neroden at gcc.gnu.org>
+
+	* configure.in: Remove skip-this-dir support.
+	* configure: Regenerate.
+
+2002-09-22  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	* Makefile.in (all): Fix multilib parallel build.
+
+Thu Sep 12 12:44:37 2002  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* sendmsg.c (nil_method): Declare not to take a variable number of
+	args.
+	(objc_msg_lookup): Cast nil_method to IMP before returning it.
+	(objc_msg_lookup_super): The same.
+
+2002-09-10  Jan Hubicka  <jh at suse.cz>
+
+	* nil_method.c (nil_method): No longer defined with variable
+	arguments.
+
+2002-07-02  Rodney Brown  <rbrown64 at csc.com.au>
+
+	* objc/encoding.h: Fix formatting.
+	* objc/hash.h: Likewise.
+	* objc/objc-api.h: Likewise.
+	* objc/runtime.h: Likewise.
+	* objc/thr.h: Likewise.
+	* archive.c: Likewise.
+	* class.c: Likewise.
+	* encoding.c: Likewise.
+	* gc.c: Likewise.
+	* hash.c: Likewise.
+	* init.c: Likewise.
+	* misc.c: Likewise.
+	* nil_method.c: Likewise.
+	* objects.c: Likewise.
+	* sarray.c: Likewise.
+	* selector.c: Likewise.
+	* sendmsg.c: Likewise.
+	* thr-mach.c: Likewise.
+	* thr.c: Likewise.
+
+2002-06-25  DJ Delorie  <dj at redhat.com>
+
+	* aclocal.m4 (GLIBCPP_CONFIGURE): Split out
+	GLIBCPP_TOPREL_CONFIGURE.
+	* configure.in: Call it before AC_CANONICAL_SYSTEM.
+	* configure: Regenerate.
+
+2002-06-21  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	* Object.m (forward, read, write): Fix unused parameter warnings.
+	* encoding.c: Include <stdlib.h>.
+	(target_flags): Mark with attribute unused.
+	(atoi): Delete.
+	* runtime.h (__objc_selector_max_index): Change to unsigned int.
+	(__objc_generate_gc_type_description): Prototype.
+	* selector.c (__objc_selector_max_index): Change to unsigned int.
+
+Mon Jun 17 18:37:42 2002  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* sendmsg.c (__objc_get_forward_imp): Fix warning by making sure
+	we always have a return value: if __objc_msg_forward does not
+	supply a forwarding implementation, return the default
+	__builtin_apply based one.
+
+2002-06-15  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	* Object.m: Fix signed/unsigned warning.
+	* Protocol.m: Likewise.
+	* archive.c: Always include stdlib.h.
+	(objc_read_short, objc_read_unsigned_short, objc_read_int,
+	objc_read_long, __objc_read_nbyte_uint, __objc_read_nbyte_ulong):
+	Fix signed/unsigned warning.
+	(objc_write_type, objc_read_type, objc_write_types,
+	objc_read_types): Ensure ctype 8-bit safety.
+	(__objc_no_write, __objc_no_read): Mark unused parameters.
+	* class.c (class_table_setup): Specify void arg.
+	* encoding.c (atoi, objc_sizeof_type, objc_alignof_type,
+	objc_skip_typespec, objc_skip_offset,
+	objc_layout_structure_next_member): Ensure ctype 8-bit safety.
+	(objc_layout_structure_next_member): Ensure variables are
+	initialized.
+	* gc.c (__objc_generate_gc_type_description,
+	class_ivar_set_gcinvisible): Mark unused parameters.
+	* init.c (__objc_send_load, __objc_destroy_class_tree_node): Mark
+	unused parameters.
+	(__objc_init_protocols) Fix signed/unsigned warning.
+	* nil_method.c (nil_method): Mark unused parameters.
+	* thr.h (objc_thread_callback): Specify void arg.
+	* sarray.c (sarray_new, sarray_realloc, sarray_free): Fix
+	signed/unsigned warning.
+	(sarray_free): Fix formatting.
+	* selector.c (sel_types_match): Ensure ctype 8-bit safety.
+	* sendmsg.c (__objc_init_install_dtable) Mark unused parameters.
+
+2002-06-09  Andreas Jaeger  <aj at suse.de>
+
+	* encoding.c (objc_layout_structure_next_member): Remove unused
+	variable.
+
+2002-05-20  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	* Makefile.in (SHELL): Set to @SHELL at .
+	(WARN_CFLAGS): New.
+	(ALL_CFLAGS): Add $(WARN_CFLAGS).
+
+2002-05-16  Rainer Orth  <ro at TechFak.Uni-Bielefeld.DE>
+
+	* aclocal.m4: Allow for PWDCMD to override hardcoded pwd.
+	* configure: Regenerate.
+
+2002-05-08  Alexandre Oliva  <aoliva at redhat.com>
+
+	* configure.in (ORIGINAL_LD_FOR_MULTILIBS): Preserve LD at
+	script entry, and set LD to it when configuring multilibs.
+	* configure: Rebuilt.
+
+2002-04-19  David O'Brien  <obrien at FreeBSD.org>
+
+	* encoding.c (MAX, MIN, ROUNDING): #undef before defining.
+
+2002-04-09  Hans-Peter Nilsson  <hp at bitrange.com>
+
+	PR objc/6107
+	* objc/objc-api.h (struct objc_protocol_list): Change type of
+	member count from int to size_t.
+
+2002-02-11  Franz Sirl  <Franz.Sirl-kernel at lauterbach.com>
+
+	PR libobjc/4039
+	* aclocal.m4: Replace with version copied from libstdc++-v3.
+	* configure.in: Update for changes to aclocal and Makefile.
+	* configure: Regenerate.
+	* Makefile.in: Correct install of multilibs and shared libs, use
+	INSTALL_DATA for include files.
+
+Mon Dec 17 17:02:12 2001  Nicola Pero  <nicola at brainstorm.co.uk>
+
+	* init.c (__objc_exec_class): Fixed bug in the loop on unclaimed
+	categories - when an unclaimed category was found, the loop was
+	doing two steps forward instead of one, so that in certain cases
+	it was failing to properly load all the categories.  (Reported
+	with fix by Alexander Malmberg <alexander at malmberg.org>).
+
+2001-11-14  Aldy Hernandez  <aldyh at redhat.com>
+
+	* encoding.c: Add target_flags.
+
+2001-11-07  Aldy Hernandez  <aldyh at redhat.com>
+
+	 * objc/objc-api.h (_C_VECTOR): New.
+
+	 * encoding.c (VECTOR_TYPE): New.
+
+Mon Oct 29 21:29:21 2001  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* class.c: Rewritten the class table to use optimized, lock-free
+	lookup.  This more than doubles the speed of class method
+	invocations.  (class_table_setup), (class_table_insert),
+	(class_table_replace), (class_table_get_safe),
+	(class_table_next), (class_table_print),
+	(class_table_print_histogram): New functions.
+	(__objc_init_class_tables): Use class_table_setup.
+	(__objc_add_class_to_hash): Use class_table_get_safe and
+	class_table_insert.  (objc_lookup_class), (objc_get_class): Do not
+	assert the existence of the table; do not lock the runtime; use
+	class_table_get_safe.  (objc_next_class): Use class_table_next.
+	(__objc_resolve_class_links): Use class_table_next.
+	(class_pose_as): Use class_table_replace.
+
+2001-09-10  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* gc.c: Removed the DEBUG declaration.
+
+Wed Jul 18 12:48:56 2001  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* thr.c (objc_mutex_lock): Invoke __objc_thread_id directly,
+	rather than through objc_thread_id, to save a function call.
+	(objc_mutex_trylock, objc_mutex_unlock, objc_condition_wait):
+	Ditto.
+
+Mon Jul 16 12:15:00 2001  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* objc/objc-api.h (object_is_class): Fixed - buggy code was trying
+	to cast an id to a Class, which can not be done.  Make the check
+	by using CLS_ISMETA on the class pointer instead.
+	(object_is_meta_class): Similar fix.
+
+2001-06-09  Alexandre Oliva  <aoliva at redhat.com>, Stephen L Moshier  <moshier at mediaone.net>
+
+	* configure.in (AC_EXEEXT): Work around in case it expands to
+	nothing, as in autoconf 2.50.
+	* acinclude.m4: Likewise.
+	* configure: Rebuilt.
+
+2001-06-08  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* THREADS: Explain that when we compile libobjc inside GCC, we
+	always use thr-objc.c as a backend, which uses GCC's thread code.
+
+2001-06-06  Richard Frith-Macdonald  <rrfm at gnu.org>
+
+	* init.c (__objc_send_message_in_list): When setting a new entry
+	in __objc_load_methods use the method IMP as key, but check to see
+	if the method is in the hashtable by looking at the IMP also.
+	Also ... call the method after adding it to the hashtable rather
+	than before ... thus preventing an obscure possibility of infinite
+	recursion if a +load method itself loads a subclass.
+
+2001-05-25  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* init.c (__objc_send_message_in_list): When setting a new entry
+	in __objc_load_methods use the method name as key, not the method
+	IMP (reported by Richard Frith-Macdonald <richard at brainstorm.co.uk>).
+
+2001-05-09  Joseph S. Myers  <jsm28 at cam.ac.uk>
+
+	* objc-features.texi: Move to ../gcc/objc.texi.
+	* fdl.texi: Remove.
+	* Makefile.in: Don't generate documentation from
+	objc-features.texi.
+
+2001-05-01  Mark Mitchell  <mark at codesourcery.com>
+
+	* fdl.texi: New file.
+	* objc-features.texi: Simplify.
+	* Makefile.in: Adjust accordingly.
+
+2001-04-30  Mark Mitchell  <mark at codesourcery.com>
+
+	* objc-features.texi: Use the GFDL.
+
+Wed Mar 21 04:44:58 EST 2001  John Wehle  (john at feith.com)
+
+	* encoding.c (REAL_TYPE): Define.
+
+2001-03-19  David Edelsohn  <edelsohn at gnu.org>
+
+	* encoding.c (TYPE_MODE): Define.
+
+2001-03-14  Nicola Pero  <n.pero at mi.flashnet.it>
+
+	* thr.c (objc_thread_add): New function.
+	(objc_thread_remove): Ditto.
+	* objc/thr.h: Declare them.
+	* libobjc.def: Mention them.
+
+2001-02-28  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* objc-features.texi: Document the @compatibility_alias compiler
+	directive (description from Nicola Pero <n.pero at mi.flashnet.it>).
+
+Fri Feb 23 18:12:00 2001  Rainer Orth  <ro at TechFak.Uni-Bielefeld.DE>
+
+	* sendmsg.c (__objc_forward): Delete strlen() declaration.
+
+2001-02-08  Geoffrey Keating  <geoffk at redhat.com>
+
+	* configure.in: Don't run AC_PROG_CC_WORKS or AC_EXEEXT, because
+	we're not interested in the result and they might fail.
+	* configure: Regenerated.
+
+2001-01-12  Joseph S. Myers  <jsm28 at cam.ac.uk>
+
+	* objc-features.texi: Use @email.
+
+2001-01-12  Joseph S. Myers  <jsm28 at cam.ac.uk>
+
+	* sendmsg.c (__objc_print_dtable_stats): Don't use #ifdef inside
+	printf.
+
+2000-01-11  Richard Earnshaw  <rearnsha at arm.com>
+
+	* encoding.c (STRUCTURE_SIZE_BOUNDARY): Redefine in a way that
+	determines the value dynamically.
+
+Wed Jan  3 00:49:10 2001  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* sendmsg.c: Added __objc_msg_forward, a hook that allows external
+	libraries to provide a function that returns the real forwarding
+	function. This can alleviate problems __builtin_apply() and
+	friends have on various platforms. (Solution suggested by Helge
+	Hess.)
+
+	* objc/objc-api.h: Define __objc_msg_forward.
+
+	* sendmsg.c: Define gen_rtx_REG.
+
+2000-12-06      Ralf Corsepius <corsepiu at faw.uni-ulm.de>
+
+	* thr-rtems.c: New file. Stub to compile.
+
+2000-09-06  Alexandre Oliva  <aoliva at redhat.com>
+
+	* configure: Rebuilt with new libtool.m4.
+
+Tue Aug 15 00:38:56 2000  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* configure.in: Create a config.h file. Check for <sched.h>.
+	* configure: Regenerate.
+
+	* config.h.in: Check for <sched.h>.
+
+2000-08-14  Zack Weinberg  <zack at wolery.cumb.org>
+
+	* configure: Regenerate after change to ../libtool.m4.
+
+2000-08-14  Andreas Schwab  <schwab at suse.de>
+
+	* objc-features.texi (Top): Move @menu at end of node.
+
+2000-08-11  Manfred Hollstein  <manfredh at redhat.com>
+
+	* objc-features.texi: Move @node Top before @menu.
+
+Sun Aug  6 23:27:49 2000  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* objc-features.texi: Documented the new -fconstant-string-class
+	option.
+
+Sun Aug  6 22:51:16 2000  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* thr-posix.c: Integrated Chris Ball's <cball at fmco.com> changes to
+	improve the Posix thread support for Objective-C.
+
+2000-08-04  Zack Weinberg  <zack at wolery.cumb.org>
+
+	* aclocal.m4: Replace copy of ../libtool.m4 with
+	sinclude(../libtool.m4).
+
+Fri Jul 28 08:58:02 2000  Nicola Pero  <nicola at brainstorm.co.uk>
+
+	* configure.in: Added libtool support; build shared libraries
+	if --enable-shared was passed on command line.
+	* Makefile.in: Modified most compilation commands to use libtool.
+	* aclocal.m4: New symbolic link to the ../libtool.m4, from the
+	libtool distribution.
+
+Sat Jul 29 00:10:21 2000  Ovidiu Predescu  <ovidiu at cup.hp.com>
+
+	* sarray.c, Object.m: Removed the explicit prototypes for strlen
+	and memcpy on 64-bit platforms (Suggested by Rodney Brown
+	<rdb at cup.hp.com>).
+
+2000-05-12  H.J. Lu  (hjl at gnu.org)
+
+	* Makefile.in (GTHREAD_FLAGS): New.
+	(ALL_CFLAGS): Add $(GTHREAD_FLAGS).
+	(OBJC_THREAD_FILE): Changed to thr-objc.
+
+	* configure.in (GTHREAD_FLAGS): New, check and replace it for
+	Makefile.
+	(OBJC_THREAD_FILE): Removed.
+
+	* thr-objc.c: New.
+
+2000-07-13  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	* objc/hash.h: Include string.h.
+
+2000-04-15  David Edelsohn  <edelsohn at gnu.org>
+
+	* Object.m (strlen): 64-bit PowerPC is a 64bit platform as well.
+
+2000-04-12  Jakub Jelinek  <jakub at redhat.com>
+
+	* Object.m (strlen): Provide prototype on all 64bit platforms,
+	not only alpha.
+	* sarray.c (memcpy): Likewise.
+	* encoding.c (objc_layout_finish_structure): Don't use
+	ROUND_TYPE_ALIGN on sparc.
+
+	* encoding.c (objc_layout_structure_next_member): Do the whole
+	procedure even for the first member, so that we get correct
+	alignment.
+
+2000-03-29  Zack Weinberg  <zack at wolery.cumb.org>
+
+	* objc/Protocol.h, objc/objc-list.h: Change #endif labels to
+	comments.
+
+2000-02-23  Zack Weinberg  <zack at wolery.cumb.org>
+
+	* Makefile.in: Add -DIN_TARGET_LIBS to ALL_CFLAGS.
+
+Thu Sep 23 07:19:12 1999   Chris Ball <cball at fmco.com>
+
+	* thr-posix.c (__objc_mutex_deallocate): made deallocate work.
+
+Tue Sep 21 07:47:10 1999  Jeffrey A Law  (law at cygnus.com)
+
+	* Makefile.in (gc.o, gc_gc.o): Do not pass -fgnu-runtime to
+	the compiler when building C code.
+
+Fri Aug  6 23:32:29 1999  Daniel Jacobowitz <drow at drow.them.org>
+
+	* Makefile.in (FLAGS_TO_PASS): Include prefix, exec_prefix,
+	libdir, libsubdir and tooldir.
+
+Mon Jun 21 05:40:15 1999  John David Anglin <dave at hiauly1>
+
+	* init.c (__objc_force_linking): Make global.
+
+Thu May 20 03:20:59 1999  Jeffrey A Law  (law at cygnus.com)
+
+	* configure.in (AC_EXEEXT): Remove call.
+	(compiler_name): Explicitly check with no extension and .exe
+	extension.
+	* configure: Regenerate.
+
+Sun Apr 25 01:15:34 1999  Mumit Khan  <khan at xraylith.wisc.edu>
+
+	* Makefile.in (CC1OBJ): Define in terms of CC.
+	(runtime-info.h): Use.
+
+Fri April 8 08:21:07 1999 Ovidiu Predescu <ovidiu at cup.hp.com>
+
+	* objc-features.texi: Updated the URL to Boehm's GC page.
+
+Fri Mar 26 23:41:07 1999 Ovidiu Predescu <ovidiu at cup.hp.com>
+
+	* archive.c (__objc_code_char, __objc_write_char): Explicitly specify
+	the char as being signed (patch from Daniel Jacobowitz
+	<drow at false.org>).
+
+Wed Mar 24 22:41:28 1999  Mumit Khan  <khan at xraylith.wisc.edu>
+
+	* configure.in (AC_PREREQ): Update to 2.13.
+	(AC_EXEEXT): Call to find possible file extension.
+	(compiler_name): Use.
+	* configure: Regenerate.
+
+Wed Jan 27 02:31:01 1999  Jeffrey A Law  (law at cygnus.com)
+
+	* Makefile.in (ALL_CFLAGS): Add -DIN_GCC.
+
+Tue Jan  5 01:38:53 1999  Jeffrey A Law  (law at cygnus.com)
+
+	* configure.in (thread_file): Correct and simplify code to find
+	the thread file.
+	* configure: Rebuilt.
+
+1998-11-26  Manfred Hollstein  <manfred at s-direktnet.de>
+
+	* configure.in (compiler_name): Add check to detect if this
+	language's compiler has been built.
+	* configure: Regenerate.
+
+Mon Nov 23 16:50:28 1998  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	*  configure.in: Use AC_PREREQ(2.12.1).
+
+Thu Nov 19 20:33:37 1998  Jeffrey A Law  (law at cygnus.com)
+
+	* Makefile.in (runtime-info.h): Avoid GNU make extensions.
+
+Sun Nov  8 17:46:14 1998  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	* Makefile.in (INCLUDES): Add -I$(srcdir)/$(MULTISRCTOP)../include.
+
+Thu Oct 22 14:34:06 1998  Kaveh R. Ghazi  <ghazi at caip.rutgers.edu>
+
+	* configure.in: Use AC_CONFIG_AUX_DIR($topsrcdir).
+
+Sat Oct 17 05:21:31 1998  Ovidiu Predescu  <ovidiu at slip.net>
+
+	* objc-features.texi (Top): Changed the email address.
+	* objc-features.texi (Garbage Collection): Use @uref instead of @url.
+
+Mon Oct 11 21:25:27 1998  Ovidiu Predescu  <ovidiu at slip.net>
+
+	* encoding.c: Redefine get_inner_array_type to get the first entry
+	in the structure.
+
+Thu Oct  8 12:21:14 1998  Richard Frith-Macdonald <richard at brainstorm.co.uk>
+
+	* encoding.c (objc_skip_type_qualifiers): Handle _C_BYREF.
+	(objc_get_type_qualifiers): Similarly.
+	* objc/encoding.h (_C_BYREF): Define.
+	(_F_BYREF): Define.
+
+1998-10-07  David S. Miller  <davem at pierdol.cobaltmicro.com>
+
+	* objc/sarray.h: Make boffset be an unsigned long when sparc so it
+	works out on 64-bit systems.
+
+Tue Oct  6 20:32:06 1998  Alexandre Oliva  <oliva at dcc.unicamp.br>
+
+	* Makefile.in (INCLUDES): Make it multilib-friendly.
+
+Fri Oct  2 07:12:14 1998  H.J. Lu  (hjl at gnu.org)
+
+	* Makefile.in (INCLUDES): Add -I$(srcdir)/../gcc.
+
+Thu Oct  1 22:33:03 1998 Robert Lipe  <robertl at dgii.com>
+			 Jeffrey A Law  (law at cygnus.com)
+
+	* Makefile.in (INCLUDES): Reference gcc via $MULTIBUILDTOP.
+	(FLAGS_TO_PASS): Added.
+	(runtime-info.h): Reference cc1ibj via $MULTIBUILDTOP.
+
+	* archive.c: Change config.h to tconfig.h.
+
+	* configure.in: Find gcc's object directory even for multilibs.
+
+Wed Sep 30 18:17:17 1998  Robert Lipe  <robertl at dgii.com>
+
+	* configure.in: Escape ^ in grep string.
+	* configure: Rebuilt.
+
+Wed Sep 30 09:14:52 1998  Jeffrey A Law  (law at cygnus.com)
+
+	* All .h files pushed down into the objc/ subdirectory.
+	* Makefile.in (copy_headers): Corresponding changes.
+	* configure.in (AC_INIT): Corresponding changes.
+	* configure: Rebuilt.
+
+1998-09-30  Ben Elliston  <bje at cygnus.com>
+	    Jeff Law	  <law at cygnus.com>
+
+	* Makefile.in: Rewrite.
+
+	* configure.in: Likewise.
+
+	* configure: Regenerate.
+
+	* All .c files.  Remove "objc" prefix when including objc header
+	files.  Include tconfig.h, not ../tconfig.h.
+
+Mon Sep 21 23:27:10 1998  Ovidiu Predescu <ovidiu at slip.net>
+
+	* encoding.c (TREE_TYPE, ARRAY_TYPE): Define.
+	(get_inner_array_type): Define.
+
+1998-09-21  Ben Elliston  <bje at cygnus.com>
+
+	* New directory.  Moved files from ../gcc/objc.

Added: llvm-gcc-4.2/trunk/libobjc/Makefile.in
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/Makefile.in?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/Makefile.in (added)
+++ llvm-gcc-4.2/trunk/libobjc/Makefile.in Thu Nov  8 16:56:19 2007
@@ -0,0 +1,376 @@
+# Makefile for GNU Objective C runtime library.
+# Copyright 1993, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004,
+# 2005, 2006 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 2, 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 COPYING.  If not, write to
+#the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+#Boston, MA 02110-1301, USA.  */
+
+#This was cribbed from the libchill, libiberty and libstdc++
+#Makefile.in files.  Some of this stuff may be unnecessary and
+#worthless.
+
+SHELL = @SHELL@
+MAKEOVERRIDES=
+
+#### Start of system configuration section. ####
+
+srcdir = @glibcpp_srcdir@
+VPATH = @glibcpp_srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+target_noncanonical = @target_noncanonical@
+gcc_version := $(shell cat $(srcdir)/../gcc/BASE-VER)
+host_subdir = @host_subdir@
+top_srcdir = @top_srcdir@
+multi_basedir = @multi_basedir@
+toolexecdir = @toolexecdir@
+# Toolexecdir is used only by toolexeclibdir
+toolexeclibdir = @toolexeclibdir@
+
+includedirname = @includedirname@
+libext = @libext@
+
+extra_ldflags_libobjc = @extra_ldflags_libobjc@
+
+top_builddir = .
+
+libdir = $(exec_prefix)/lib
+libsubdir = $(libdir)/gcc/$(target_noncanonical)/$(gcc_version)
+
+# Multilib support variables.
+MULTISRCTOP =
+MULTIBUILDTOP =
+MULTIDIRS =
+MULTISUBDIR =
+MULTIDO = true
+MULTICLEAN = true
+
+# Not configured per top-level version, since that doesn't get passed
+# down at configure time, but overrridden by the top-level install
+# target.
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_DATA = @INSTALL_DATA@
+
+AR = @AR@
+AR_FLAGS = rc
+
+RANLIB = @RANLIB@
+
+CC = @CC@
+CFLAGS = @CFLAGS@
+WARN_CFLAGS = -W -Wall -Wwrite-strings -Wstrict-prototypes
+ALL_CFLAGS = -I. -I$(srcdir) $(CPPFLAGS) $(DEFS) $(CFLAGS) $(WARN_CFLAGS) \
+	-DIN_GCC -DIN_TARGET_LIBS -fno-strict-aliasing -fexceptions
+
+# Libtool
+# The following strings describe the version of the obj-C library 
+# begin compiled and compatibility issues.
+# Please refer to Libtool documentation about how to manage these 
+# numbers.
+LIBOBJC_VERSION = @VERSION@
+LIBOBJC_GC_VERSION = @VERSION@
+LIBTOOL = @LIBTOOL@
+LIBTOOL_COMPILE = $(LIBTOOL) --mode=compile
+LIBTOOL_LINK    = $(LIBTOOL) --mode=link 
+LIBTOOL_INSTALL = $(LIBTOOL) --mode=install
+LIBTOOL_CLEAN   = $(LIBTOOL) --mode=clean
+#LIBTOOL_UNINSTALL = $(LIBTOOL) --mode=uninstall
+
+OBJC_GCFLAGS=-DOBJC_WITH_GC=1
+OBJC_THREAD_FILE=thr-objc
+OBJC_BOEHM_GC=@OBJC_BOEHM_GC@
+OBJC_BOEHM_GC_INCLUDES=@OBJC_BOEHM_GC_INCLUDES@
+
+INCLUDES = -I$(srcdir)/objc  -I$(srcdir)/$(MULTISRCTOP)../gcc \
+  -I$(srcdir)/$(MULTISRCTOP)../gcc/config \
+  -I$(MULTIBUILDTOP)../../$(host_subdir)/gcc \
+  -I$(srcdir)/$(MULTISRCTOP)../include \
+  $(OBJC_BOEHM_GC_INCLUDES)
+
+
+.SUFFIXES:
+.SUFFIXES: .c .m .lo
+
+.c.lo:
+	$(LIBTOOL_COMPILE) $(CC) -c $(ALL_CFLAGS) $(INCLUDES) $<
+
+.m.lo:
+	$(LIBTOOL_COMPILE) $(CC) -c $(ALL_CFLAGS) $(INCLUDES) $<
+
+# Flags to pass to a recursive make.
+FLAGS_TO_PASS = \
+	"AR=$(AR)" \
+	"AR_FLAGS=$(AR_FLAGS)" \
+	"CC=$(CC)" \
+	"CFLAGS=$(CFLAGS)" \
+	"DESTDIR=$(DESTDIR)" \
+	"LIBCFLAGS=$(LIBCFLAGS)" \
+	"EXTRA_OFILES=$(EXTRA_OFILES)" \
+	"HDEFINES=$(HDEFINES)" \
+	"INSTALL=$(INSTALL)" \
+	"INSTALL_DATA=$(INSTALL_DATA)" \
+	"INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
+	"LDFLAGS=$(LDFLAGS)" \
+	"LIBTOOL=$(LIBTOOL)" \
+	"LOADLIBES=$(LOADLIBES)" \
+	"PICFLAG=$(PICFLAG)" \
+	"RANLIB=$(RANLIB)" \
+	"SHELL=$(SHELL)" \
+	"prefix=$(prefix)" \
+	"exec_prefix=$(exec_prefix)" \
+	"libdir=$(libdir)" \
+	"libsubdir=$(libsubdir)" \
+	"tooldir=$(tooldir)"
+
+all: libobjc$(libext).la $(OBJC_BOEHM_GC)
+	: $(MAKE) ; exec $(MULTIDO) $(FLAGS_TO_PASS) multi-do DO=all
+
+# User-visible header files.
+
+OBJC_H = hash.h objc-list.h sarray.h objc.h objc-api.h \
+	 NXConstStr.h Object.h Protocol.h encoding.h typedstream.h \
+	 thr.h objc-decls.h
+
+# Modules that comprise the runtime library.
+
+OBJS =    archive.lo class.lo encoding.lo gc.lo hash.lo init.lo linking.lo \
+	  misc.lo nil_method.lo NXConstStr.lo Object.lo objects.lo \
+	  Protocol.lo sarray.lo selector.lo sendmsg.lo thr.lo \
+	  $(OBJC_THREAD_FILE).lo exception.lo
+
+OBJS_GC = archive_gc.lo class_gc.lo encoding_gc.lo gc_gc.lo hash_gc.lo \
+	  init_gc.lo linking_gc.lo misc_gc.lo nil_method_gc.lo \
+	  NXConstStr_gc.lo Object_gc.lo objects_gc.lo Protocol_gc.lo \
+	  sarray_gc.lo selector_gc.lo sendmsg_gc.lo thr_gc.lo \
+	  $(OBJC_THREAD_FILE)_gc.lo exception_gc.lo
+
+runtime-info.h: 
+	echo "" > tmp-runtime.m
+	echo "/* This file is automatically generated */" > $@
+	$(CC) $(MULTIFLAGS) -print-objc-runtime-info -S tmp-runtime.m >> $@
+	rm -f tmp-runtime.m tmp-runtime.s
+
+archive_gc.lo: archive.c
+	$(LIBTOOL_COMPILE) $(CC) -c  -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+class_gc.lo: class.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+encoding_gc.lo: encoding.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+gc.lo: gc.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(INCLUDES) $<
+
+gc_gc.lo: gc.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+hash_gc.lo: hash.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+init_gc.lo: init.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+linking.lo: linking.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(INCLUDES) $<
+
+linking_gc.lo: linking.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(OBJC_GCFLAGS) $(INCLUDES) $<
+
+misc_gc.lo: misc.c
+	$(LIBTOOL_COMPILE) $(CC) -c $(ALL_CFLAGS) -o $@ $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+nil_method_gc.lo: nil_method.c
+	$(LIBTOOL_COMPILE) $(CC) -c $(ALL_CFLAGS) -o $@ $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+NXConstStr.lo: NXConstStr.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(INCLUDES) $<
+
+NXConstStr_gc.lo: NXConstStr.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(OBJC_GCFLAGS) $(INCLUDES) $<
+
+Object.lo: Object.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(INCLUDES) $<
+
+Object_gc.lo: Object.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(OBJC_GCFLAGS) $(INCLUDES) $<
+
+objects_gc.lo: objects.c
+	$(LIBTOOL_COMPILE) $(CC) -c $(ALL_CFLAGS) -o $@ $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+Protocol.lo: Protocol.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(INCLUDES) $<
+
+Protocol_gc.lo: Protocol.m
+	$(LIBTOOL_COMPILE) $(CC) -fgnu-runtime -c -o $@ $(ALL_CFLAGS) \
+		$(OBJC_GCFLAGS) $(INCLUDES) $<
+
+sarray_gc.lo: sarray.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+selector_gc.lo: selector.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+sendmsg.lo: sendmsg.c runtime-info.h
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(INCLUDES) $<
+
+sendmsg_gc.lo: sendmsg.c runtime-info.h
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+thr_gc.lo: thr.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+$(OBJC_THREAD_FILE)_gc.lo: $(OBJC_THREAD_FILE).c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		$(INCLUDES) $<
+
+exception.lo: exception.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) \
+		-fexceptions $(INCLUDES) $<
+
+exception_gc.lo: exception.c
+	$(LIBTOOL_COMPILE) $(CC) -c -o $@ $(ALL_CFLAGS) $(OBJC_GCFLAGS) \
+		-fexceptions $(INCLUDES) $<
+
+doc: info dvi pdf html
+
+# No install-html support
+.PHONY: install-html
+install-html:
+
+libobjc$(libext).la: $(OBJS)
+	$(LIBTOOL_LINK) $(CC) -o $@ $(OBJS) \
+		-rpath $(toolexeclibdir) \
+		-version-info $(LIBOBJC_VERSION) $(extra_ldflags_libobjc)
+
+libobjc_gc$(libext).la: $(OBJS_GC)
+	$(LIBTOOL_LINK) $(CC) -o $@ $(OBJS_GC) \
+		-rpath $(toolexeclibdir) \
+		-version-info $(LIBOBJC_GC_VERSION) $(extra_ldflags_libobjc)
+
+#
+# FIXME -- The following part does not fit in the libtool context. 
+# Libtool is supposed to [going to] be able to create a win 32 DLL 
+# without extra code but since I don't have a win machine to test 
+# if it already works, I leave the old code here.
+#
+libobjc_s.a: libobjc.la
+	mv libobjc.a libobjc_s.a
+
+# Create a relocatable DLL
+libobjc.dll: libobjc_s.a libobjc_entry.o
+	$(CC) -mdll -Wl,--base-file -Wl,libobjc.base \
+		-o libobjc.dll libobjc_s.a libobjc_entry.o -lkernel32
+	$(DLLTOOL) --dllname libobjc.dll --def $(srcdir)/libobjc.def \
+		--base-file libobjc.base --output-exp libobjc.exp
+	$(GCC_FOR_TARGET) -mdll -Wl,--base-file libobjc.base libobjc.exp \
+		-o libobjc.dll libobjc_s.a libobjc_entry.o -lkernel32
+	$(DLLTOOL) --dllname libobjc.dll --def $(srcdir)/libobjc.def \
+		--base-file libobjc.base --output-exp libobjc.exp
+	$(GCC_FOR_TARGET) libobjc.exp -mdll \
+		-o libobjc.dll libobjc_s.a libobjc_entry.o -lkernel32
+	$(DLLTOOL) --dllname libobjc.dll --def $(srcdir)/libobjc.def \
+		--output-lib libobjc.a
+#
+#
+#
+#
+#
+
+info:
+dvi:
+pdf:
+html:
+
+Makefile: Makefile.in config.status
+	$(SHELL) config.status
+
+config.status: configure
+	rm -f config.cache
+	CONFIG_SITE=no-such-file CC='$(CC)' AR='$(AR)' CFLAGS='$(CFLAGS)' \
+	CPPFLAGS='$(CPPFLAGS)' $(SHELL) config.status --recheck
+
+${srcdir}/configure: @MAINT@ configure.ac
+	rm -f config.cache
+	cd ${srcdir} && autoconf
+
+install: install-libs install-headers
+
+install-libs: installdirs
+	$(SHELL) $(multi_basedir)/mkinstalldirs $(DESTDIR)$(toolexeclibdir)
+	$(LIBTOOL_INSTALL) $(INSTALL) libobjc$(libext).la $(DESTDIR)$(toolexeclibdir);
+	if [ "$(OBJC_BOEHM_GC)" ]; then \
+	  $(LIBTOOL_INSTALL) $(INSTALL) libobjc_gc$(libext).la \
+				$(DESTDIR)$(toolexeclibdir);\
+	fi
+	$(MULTIDO) $(FLAGS_TO_PASS) multi-do DO="$@"
+	@-$(LIBTOOL) --mode=finish $(DESTDIR)$(toolexeclibdir)
+
+# Copy Objective C headers to installation include directory.
+install-headers:
+	$(SHELL) $(multi_basedir)/mkinstalldirs $(DESTDIR)$(libsubdir)/$(includedirname)/objc
+	for file in $(OBJC_H); do \
+	  realfile=$(srcdir)/objc/$${file}; \
+	  $(INSTALL_DATA) $${realfile} $(DESTDIR)$(libsubdir)/$(includedirname)/objc; \
+	done
+
+check uninstall install-strip dist installcheck installdirs:
+
+mostlyclean:
+	-$(LIBTOOL_CLEAN) rm -f libobjc$(libext).la libobjc_gc$(libext).la *.lo
+	-rm -f runtime-info.h tmp-runtime.s *.o *.lo libobjc* xforward \
+		fflags *.aux *.cp *.dvi *.pdf *.fn *.info *.ky *.log *.pg \
+		*.toc *.tp *.vr *.html libobj.exp
+	@$(MULTICLEAN) multi-clean DO=mostlyclean
+
+clean: mostlyclean
+	rm -f config.log
+	@$(MULTICLEAN) multi-clean DO=clean
+
+distclean: clean
+	@$(MULTICLEAN) multi-clean DO=distclean
+	rm -f config.cache config.status Makefile configure
+
+maintainer-clean realclean: distclean
+
+.PHONY: mostlyclean clean distclean maintainer-clean all check uninstall \
+	install-strip dist installcheck installdirs 
+
+# Don't export variables to the environment, in order to not confuse
+# configure.
+.NOEXPORT:

Added: llvm-gcc-4.2/trunk/libobjc/NXConstStr.m
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/NXConstStr.m?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/NXConstStr.m (added)
+++ llvm-gcc-4.2/trunk/libobjc/NXConstStr.m Thu Nov  8 16:56:19 2007
@@ -0,0 +1,42 @@
+/* Implementation of the NXConstantString class for Objective-C.
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Contributed by Pieter J. Schoenmakers <tiggr at es.ele.tue.nl>
+
+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 2, 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 COPYING.  If not, write to
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+ 
+/* As a special exception, if you link this library with files
+   compiled with GCC to produce an executable, this does not cause
+   the resulting executable to be covered by the GNU General Public License.
+   This exception does not however invalidate any other reasons why
+   the executable file might be covered by the GNU General Public License.  */
+
+#include "objc/NXConstStr.h"
+
+ at implementation NXConstantString
+
+-(const char *) cString
+{
+  return (c_string);
+} /* -cString */
+
+-(unsigned int) length
+{
+  return (len);
+} /* -length */
+
+ at end

Added: llvm-gcc-4.2/trunk/libobjc/Object.m
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/Object.m?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/Object.m (added)
+++ llvm-gcc-4.2/trunk/libobjc/Object.m Thu Nov  8 16:56:19 2007
@@ -0,0 +1,386 @@
+/* The implementation of class Object for Objective-C.
+   Copyright (C) 1993, 1994, 1995, 1997, 2002 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 2, 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 COPYING.  If not, write to
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, if you link this library with files compiled
+   with GCC to produce an executable, this does not cause the resulting
+   executable to be covered by the GNU General Public License.  This
+   exception does not however invalidate any other reasons why the
+   executable file might be covered by the GNU General Public License. */
+
+#include <stdarg.h>
+#include "objc/Object.h"
+#include "objc/Protocol.h"
+#include "objc/objc-api.h"
+
+extern int errno;
+
+#define MAX_CLASS_NAME_LEN 256
+
+ at implementation Object
+
++ initialize
+{
+  return self;
+}
+
+- init
+{
+  return self;
+}
+
++ new
+{
+  return [[self alloc] init];
+}
+
++ alloc
+{
+  return class_create_instance(self);
+}
+
+- free
+{
+  return object_dispose(self);
+}
+
+- copy
+{
+  return [[self shallowCopy] deepen];
+}
+
+- shallowCopy
+{
+  return object_copy(self);
+}
+
+- deepen
+{
+  return self;
+}
+
+- deepCopy
+{
+  return [self copy];
+}
+
+- (Class)class
+{
+  return object_get_class(self);
+}
+
+- (Class)superClass
+{
+  return object_get_super_class(self);
+}
+
+- (MetaClass)metaClass
+{
+  return object_get_meta_class(self);
+}
+
+- (const char *)name
+{
+  return object_get_class_name(self);
+}
+
+- self
+{
+  return self;
+}
+
+- (unsigned int)hash
+{
+  return (size_t)self;
+}
+
+- (BOOL)isEqual:anObject
+{
+  return self==anObject;
+}
+
+- (int)compare:anotherObject;
+{
+  if ([self isEqual:anotherObject])
+    return 0;
+  // Ordering objects by their address is pretty useless, 
+  // so subclasses should override this is some useful way.
+  else if (self > anotherObject)
+    return 1;
+  else 
+    return -1;
+}
+
+- (BOOL)isMetaClass
+{
+  return NO;
+}
+
+- (BOOL)isClass
+{
+  return object_is_class(self);
+}
+
+- (BOOL)isInstance
+{
+  return object_is_instance(self);
+}
+
+- (BOOL)isKindOf:(Class)aClassObject
+{
+  Class class;
+
+  for (class = self->isa; class!=Nil; class = class_get_super_class(class))
+    if (class==aClassObject)
+      return YES;
+  return NO;
+}
+
+- (BOOL)isMemberOf:(Class)aClassObject
+{
+  return self->isa==aClassObject;
+}
+
+- (BOOL)isKindOfClassNamed:(const char *)aClassName
+{
+  Class class;
+
+  if (aClassName!=NULL)
+    for (class = self->isa; class!=Nil; class = class_get_super_class(class))
+      if (!strcmp(class_get_class_name(class), aClassName))
+        return YES;
+  return NO;
+}
+
+- (BOOL)isMemberOfClassNamed:(const char *)aClassName
+{
+  return ((aClassName!=NULL)
+          &&!strcmp(class_get_class_name(self->isa), aClassName));
+}
+
++ (BOOL)instancesRespondTo:(SEL)aSel
+{
+  return class_get_instance_method(self, aSel)!=METHOD_NULL;
+}
+
+- (BOOL)respondsTo:(SEL)aSel
+{
+  return ((object_is_instance(self)
+           ?class_get_instance_method(self->isa, aSel)
+           :class_get_class_method(self->isa, aSel))!=METHOD_NULL);
+}
+
++ (IMP)instanceMethodFor:(SEL)aSel
+{
+  return method_get_imp(class_get_instance_method(self, aSel));
+}
+
+// Indicates if the receiving class or instance conforms to the given protocol
+// not usually overridden by subclasses
+//
+// Modified 9/5/94 to always search the class object's protocol list, rather
+// than the meta class.
+
++ (BOOL) conformsTo: (Protocol*)aProtocol
+{
+  size_t i;
+  struct objc_protocol_list* proto_list;
+  id parent;
+
+  for (proto_list = ((Class)self)->protocols;
+       proto_list; proto_list = proto_list->next)
+    {
+      for (i=0; i < proto_list->count; i++)
+      {
+        if ([proto_list->list[i] conformsTo: aProtocol])
+          return YES;
+      }
+    }
+
+  if ((parent = [self superClass]))
+    return [parent conformsTo: aProtocol];
+  else
+    return NO;
+}
+
+- (BOOL) conformsTo: (Protocol*)aProtocol
+{
+  return [[self class] conformsTo:aProtocol];
+}
+
+- (IMP)methodFor:(SEL)aSel
+{
+  return (method_get_imp(object_is_instance(self)
+                         ?class_get_instance_method(self->isa, aSel)
+                         :class_get_class_method(self->isa, aSel)));
+}
+
++ (struct objc_method_description *)descriptionForInstanceMethod:(SEL)aSel
+{
+  return ((struct objc_method_description *)
+           class_get_instance_method(self, aSel));
+}
+
+- (struct objc_method_description *)descriptionForMethod:(SEL)aSel
+{
+  return ((struct objc_method_description *)
+           (object_is_instance(self)
+            ?class_get_instance_method(self->isa, aSel)
+            :class_get_class_method(self->isa, aSel)));
+}
+
+- perform:(SEL)aSel
+{
+  IMP msg = objc_msg_lookup(self, aSel);
+  if (!msg)
+    return [self error:"invalid selector passed to %s", sel_get_name(_cmd)];
+  return (*msg)(self, aSel);
+}
+
+- perform:(SEL)aSel with:anObject
+{
+  IMP msg = objc_msg_lookup(self, aSel);
+  if (!msg)
+    return [self error:"invalid selector passed to %s", sel_get_name(_cmd)];
+  return (*msg)(self, aSel, anObject);
+}
+
+- perform:(SEL)aSel with:anObject1 with:anObject2
+{
+  IMP msg = objc_msg_lookup(self, aSel);
+  if (!msg)
+    return [self error:"invalid selector passed to %s", sel_get_name(_cmd)];
+  return (*msg)(self, aSel, anObject1, anObject2);
+}
+
+- (retval_t)forward:(SEL)aSel :(arglist_t)argFrame
+{
+  (void) argFrame; /* UNUSED */
+  return (retval_t)[self doesNotRecognize: aSel];
+}
+
+- (retval_t)performv:(SEL)aSel :(arglist_t)argFrame
+{
+  return objc_msg_sendv(self, aSel, argFrame);
+}
+
++ poseAs:(Class)aClassObject
+{
+  return class_pose_as(self, aClassObject);
+}
+
+- (Class)transmuteClassTo:(Class)aClassObject
+{
+  if (object_is_instance(self))
+    if (class_is_class(aClassObject))
+      if (class_get_instance_size(aClassObject)==class_get_instance_size(isa))
+        if ([self isKindOf:aClassObject])
+          {
+            Class old_isa = isa;
+            isa = aClassObject;
+            return old_isa;
+          }
+  return nil;
+}
+
+- subclassResponsibility:(SEL)aSel
+{
+  return [self error:"subclass should override %s", sel_get_name(aSel)];
+}
+
+- notImplemented:(SEL)aSel
+{
+  return [self error:"method %s not implemented", sel_get_name(aSel)];
+}
+
+- shouldNotImplement:(SEL)aSel
+{
+  return [self error:"%s should not implement %s", 
+	             object_get_class_name(self), sel_get_name(aSel)];
+}
+
+- doesNotRecognize:(SEL)aSel
+{
+  return [self error:"%s does not recognize %s",
+                     object_get_class_name(self), sel_get_name(aSel)];
+}
+
+- error:(const char *)aString, ...
+{
+#define FMT "error: %s (%s)\n%s\n"
+  char fmt[(strlen((char*)FMT)+strlen((char*)object_get_class_name(self))
+            +((aString!=NULL)?strlen((char*)aString):0)+8)];
+  va_list ap;
+
+  sprintf(fmt, FMT, object_get_class_name(self),
+                    object_is_instance(self)?"instance":"class",
+                    (aString!=NULL)?aString:"");
+  va_start(ap, aString);
+  objc_verror(self, OBJC_ERR_UNKNOWN, fmt, ap);
+  va_end(ap);
+  return nil;
+#undef FMT
+}
+
++ (int)version
+{
+  return class_get_version(self);
+}
+
++ setVersion:(int)aVersion
+{
+  class_set_version(self, aVersion);
+  return self;
+}
+
++ (int)streamVersion: (TypedStream*)aStream
+{
+  if (aStream->mode == OBJC_READONLY)
+    return objc_get_stream_class_version (aStream, self);
+  else
+    return class_get_version (self);
+}
+
+// These are used to write or read the instance variables 
+// declared in this particular part of the object.  Subclasses
+// should extend these, by calling [super read/write: aStream]
+// before doing their own archiving.  These methods are private, in
+// the sense that they should only be called from subclasses.
+
+- read: (TypedStream*)aStream
+{
+  (void) aStream; /* UNUSED */
+  // [super read: aStream];  
+  return self;
+}
+
+- write: (TypedStream*)aStream
+{
+  (void) aStream; /* UNUSED */
+  // [super write: aStream];
+  return self;
+}
+
+- awake
+{
+  // [super awake];
+  return self;
+}
+
+ at end

Added: llvm-gcc-4.2/trunk/libobjc/Protocol.m
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/Protocol.m?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/Protocol.m (added)
+++ llvm-gcc-4.2/trunk/libobjc/Protocol.m Thu Nov  8 16:56:19 2007
@@ -0,0 +1,182 @@
+/* This file contains the implementation of class Protocol.
+   Copyright (C) 1993, 2004 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 2, 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 COPYING.  If not, write to
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+ 
+/* As a special exception, if you link this library with files
+   compiled with GCC to produce an executable, this does not cause
+   the resulting executable to be covered by the GNU General Public License.
+   This exception does not however invalidate any other reasons why
+   the executable file might be covered by the GNU General Public License.  */
+
+#include "objc/Protocol.h"
+#include "objc/objc-api.h"
+
+/* Method description list */
+struct objc_method_description_list {
+        int count;
+        struct objc_method_description list[1];
+};
+
+
+ at implementation Protocol
+{
+ at private
+        char *protocol_name;
+        struct objc_protocol_list *protocol_list;
+        struct objc_method_description_list *instance_methods, *class_methods; 
+}
+
+/* Obtaining attributes intrinsic to the protocol */
+
+- (const char *)name
+{
+  return protocol_name;
+}
+
+/* Testing protocol conformance */
+
+- (BOOL) conformsTo: (Protocol *)aProtocolObject
+{
+  size_t i;
+  struct objc_protocol_list* proto_list;
+
+  if (aProtocolObject == nil)
+    return NO;
+
+  if (!strcmp(aProtocolObject->protocol_name, self->protocol_name))
+    return YES;
+
+  for (proto_list = protocol_list; proto_list; proto_list = proto_list->next)
+    {
+      for (i=0; i < proto_list->count; i++)
+	{
+	  if ([proto_list->list[i] conformsTo: aProtocolObject])
+	    return YES;
+	}
+    }
+
+  return NO;
+}
+
+/* Looking up information specific to a protocol */
+
+- (struct objc_method_description *) descriptionForInstanceMethod:(SEL)aSel
+{
+  int i;
+  struct objc_protocol_list* proto_list;
+  const char* name = sel_get_name (aSel);
+  struct objc_method_description *result;
+
+  if (instance_methods)
+    for (i = 0; i < instance_methods->count; i++)
+      {
+	if (!strcmp ((char*)instance_methods->list[i].name, name))
+	  return &(instance_methods->list[i]);
+      }
+
+  for (proto_list = protocol_list; proto_list; proto_list = proto_list->next)
+    {
+      size_t j;
+      for (j=0; j < proto_list->count; j++)
+	{
+	  if ((result = [proto_list->list[j]
+			 descriptionForInstanceMethod: aSel]))
+	    return result;
+	}
+    }
+
+  return NULL;
+}
+
+- (struct objc_method_description *) descriptionForClassMethod:(SEL)aSel;
+{
+  int i;
+  struct objc_protocol_list* proto_list;
+  const char* name = sel_get_name (aSel);
+  struct objc_method_description *result;
+
+  if (class_methods)
+    for (i = 0; i < class_methods->count; i++)
+      {
+	if (!strcmp ((char*)class_methods->list[i].name, name))
+	  return &(class_methods->list[i]);
+      }
+
+  for (proto_list = protocol_list; proto_list; proto_list = proto_list->next)
+    {
+      size_t j;
+      for (j=0; j < proto_list->count; j++)
+	{
+	  if ((result = [proto_list->list[j]
+			 descriptionForClassMethod: aSel]))
+	    return result;
+	}
+    }
+
+  return NULL;
+}
+
+- (unsigned) hash
+{
+  /* Compute a hash of the protocol_name; use the same hash algorithm
+   * that we use for class names; protocol names and class names are
+   * somewhat similar types of string spaces.
+   */
+  int hash = 0, index;
+  
+  for (index = 0; protocol_name[index] != '\0'; index++)
+    {
+      hash = (hash << 4) ^ (hash >> 28) ^ protocol_name[index];
+    }
+
+  hash = (hash ^ (hash >> 10) ^ (hash >> 20));
+
+  return hash;
+}
+
+/*
+ * Equality between formal protocols is only formal (nothing to do
+ * with actually checking the list of methods they have!).  Two formal
+ * Protocols are equal if and only if they have the same name.
+ *
+ * Please note (for comparisons with other implementations) that
+ * checking the names is equivalent to checking that Protocol A
+ * conforms to Protocol B and Protocol B conforms to Protocol A,
+ * because this happens iff they have the same name.  If they have
+ * different names, A conforms to B if and only if A includes B, but
+ * the situation where A includes B and B includes A is a circular
+ * dependency between Protocols which is forbidden by the compiler, so
+ * A conforms to B and B conforms to A with A and B having different
+ * names is an impossible case.
+ */
+- (BOOL) isEqual: (id)obj
+{
+  if (obj == self)
+    return YES;
+
+  if ([obj isKindOf: [Protocol class]])
+    {
+      if (strcmp (protocol_name, ((Protocol *)obj)->protocol_name) == 0)
+	return YES;
+    }
+
+  return NO;
+}
+ at end
+

Added: llvm-gcc-4.2/trunk/libobjc/README
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/README?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/README (added)
+++ llvm-gcc-4.2/trunk/libobjc/README Thu Nov  8 16:56:19 2007
@@ -0,0 +1,104 @@
+
+GNU Objective C notes
+*********************
+
+This document is to explain what has been done, and a little about how
+specific features differ from other implementations.  The runtime has
+been completely rewritten in gcc 2.4.  The earlier runtime had several
+severe bugs and was rather incomplete.  The compiler has had several
+new features added as well.
+
+This is not documentation for Objective C, it is usable to someone
+who knows Objective C from somewhere else.
+
+
+Runtime API functions
+=====================
+
+The runtime is modeled after the NeXT Objective C runtime.  That is,
+most functions have semantics as it is known from the NeXT.  The
+names, however, have changed.  All runtime API functions have names
+of lowercase letters and underscores as opposed to the
+`traditional' mixed case names.  
+	The runtime api functions are not documented as of now.
+Someone offered to write it, and did it, but we were not allowed to
+use it by his university (Very sad story).  We have started writing
+the documentation over again.  This will be announced in appropriate
+places when it becomes available.
+
+
+Protocols
+=========
+
+Protocols are now fully supported.  The semantics is exactly as on the
+NeXT.  There is a flag to specify how protocols should be typechecked
+when adopted to classes.  The normal typechecker requires that all
+methods in a given protocol must be implemented in the class that
+adopts it -- it is not enough to inherit them.  The flag
+`-Wno-protocol' causes it to allow inherited methods, while
+`-Wprotocols' is the default which requires them defined.
+
+
++load
+===========
+This method, if defined, is called for each class and category
+implementation when the class is loaded into the runtime.  This method
+is not inherited, and is thus not called for a subclass that doesn't
+define it itself.  Thus, each +load method is called exactly once by
+the runtime.  The runtime invocation of this method is thread safe.
+
+
++initialize 
+===========
+
+This method, if defined, is called before any other instance or class
+methods of that particular class.  For the GNU runtime, this method is 
+not inherited, and is thus not called as initializer for a subclass that 
+doesn't define it itself.  Thus, each +initialize method is called exactly 
+once by the runtime (or never if no methods of that particular class is 
+never called).  It is wise to guard against multiple invocations anyway 
+to remain portable with the NeXT runtime.  The runtime invocation of 
+this method is thread safe.
+
+
+Passivation/Activation/Typedstreams
+===================================
+
+This is supported in the style of NeXT TypedStream's.  Consult the
+headerfile Typedstreams.h for api functions.  I (Kresten) have
+rewritten it in Objective C, but this implementation is not part of
+2.4, it is available from the GNU Objective C prerelease archive. 
+   There is one difference worth noting concerning objects stored with
+objc_write_object_reference (aka NXWriteObjectReference).  When these
+are read back in, their object is not guaranteed to be available until
+the `-awake' method is called in the object that requests that object.
+To objc_read_object you must pass a pointer to an id, which is valid
+after exit from the function calling it (like e.g. an instance
+variable).  In general, you should not use objects read in until the
+-awake method is called.
+
+
+Acknowledgements
+================
+
+The GNU Objective C team: Geoffrey Knauth <gsk at marble.com> (manager),
+Tom Wood <wood at next.com> (compiler) and Kresten Krab Thorup
+<krab at iesd.auc.dk> (runtime) would like to thank a some people for
+participating in the development of the present GNU Objective C.
+
+Paul Burchard <burchard at geom.umn.edu> and Andrew McCallum
+<mccallum at cs.rochester.edu> has been very helpful debugging the
+runtime.   Eric Herring <herring at iesd.auc.dk> has been very helpful
+cleaning up after the documentation-copyright disaster and is now
+helping with the new documentation.
+
+Steve Naroff <snaroff at next.com> and Richard Stallman
+<rms at gnu.ai.mit.edu> has been very helpful with implementation details
+in the compiler.
+
+
+Bug Reports
+===========
+
+Please read the section `Submitting Bugreports' of the gcc manual
+before you submit any bugs.

Added: llvm-gcc-4.2/trunk/libobjc/README.threads
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/README.threads?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/README.threads (added)
+++ llvm-gcc-4.2/trunk/libobjc/README.threads Thu Nov  8 16:56:19 2007
@@ -0,0 +1,50 @@
+==============================================================================
+README.threads - Wed Nov 29 15:16:24 EST 1995
+------------------------------------------------------------------------------
+
+Limited documentation is available in the THREADS file.
+
+This version has been tested on Sun Solaris, SGI Irix, and Windows NT.
+It should also work on any single threaded system.
+
+Thanks go to the following people for help test and debug the library:
+
+	Scott Christley, scottc at ocbi.com
+	Andrew McCallum, mccallum at cs.rochester.edu
+
+galen
+gchunt at cs.rochester.edu
+
+Any questions, bug reports, etc should be directed to:
+
+Scott Christley, scottc at ocbi.com
+
+Please do not bug Galen with email as he no longer supports the code.
+
+==============================================================================
+Changes from prior releases (in revered chronological order):
+------------------------------------------------------------------------------
+
+* Fixed bug in copy part of sarray_realloc.  I had an < which should
+  have been <=. (Bug report from Scott).
+
+------------------------------------------------------------------------------
+
+* Support for DEC OSF/1 is definitely broken.  My programs always
+  seg-fault when I link with libpthreads.a.
+
+* Thread id's are no longer int's, but are instead of type
+  _objc_thread_t which is typedef'ed from a void *.  An invalid thread
+  id is denoted by NULL and not -1 as before.
+
+------------------------------------------------------------------------------
+
+* Renamed thread-winnt.c to thread-win32.c to better reflect support
+  for the API on both Windows NT and Windows 95 platforms.  
+  (Who knows, maybe even Win32s :-).
+
+* Fixed bugs in Win32 support as per report from Scott Christley.
+
+* Fixed bug in sarray_get as per report from Scott Christley.
+
+	

Added: llvm-gcc-4.2/trunk/libobjc/THREADS
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/THREADS?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/THREADS (added)
+++ llvm-gcc-4.2/trunk/libobjc/THREADS Thu Nov  8 16:56:19 2007
@@ -0,0 +1,377 @@
+This file describes in little detail the modifications to the
+Objective-C runtime needed to make it thread safe. 
+
+First off, kudos to Galen Hunt who is the author of this great work.
+
+If you have an comments or just want to know where to
+send me money to express your undying gratitude for threading the
+Objective-C runtime you can reach Galen at:
+
+	gchunt at cs.rochester.edu
+
+Any questions, comments, bug reports, etc. should send email either to the
+GCC bug account or to:
+
+	Scott Christley <scottc at net-community.com>
+
+* Sarray Threading:
+
+The most critical component of the Objective-C runtime is the sparse array
+structure (sarray).  Sarrays store object selectors and implementations.  
+Following in the tradition of the Objective-C runtime, my threading
+support assumes that fast message dispatching is far more important
+than *ANY* and *ALL* other operations.  The message dispatching thus
+uses *NO* locks on any kind.  In fact, if you look in sarray.h, you
+will notice that the message dispatching has not been modified.
+Instead, I have modified the sarray management functions so that all
+updates to the sarray data structure can be made in parallel will
+message dispatching.  
+
+To support concurrent message dispatching, no dynamically allocated
+sarray data structures are freed while more than one thread is
+operational.  Sarray data structures that are no longer in use are
+kept in a linked list of garbage and are released whenever the program
+is operating with a single thread.  The programmer can also flush the 
+garbage list by calling sarray_remove_garbage when the programmer can
+ensure that no message dispatching is taking place concurrently.  The
+amount of un-reclaimed sarray garbage should normally be extremely
+small in a real program as sarray structures are freed only when using
+the "poseAs" functionality and early in program initialization, which
+normally occurs while the program is single threaded.
+
+******************************************************************************
+* Static Variables:
+
+The following variables are either statically or globally defined. This list 
+does not include variables which are internal to implementation dependent 
+versions of thread-*.c.
+
+The following threading designations are used:
+	SAFE   : Implicitly thread safe.
+	SINGLE : Must only be used in single thread mode.
+	MUTEX  : Protected by single global mutex objc_runtime_mutex.
+	UNUSED : Not used in the runtime.
+
+Variable Name:			Usage:  Defined:	Also used in:
+===========================	======	============	=====================
+__objc_class_hash		MUTEX	class.c
+__objc_class_links_resolved	UNUSED	class.c		runtime.h
+__objc_class_number		MUTEX	class.c
+__objc_dangling_categories	UNUSED	init.c
+__objc_module_list		MUTEX	init.c
+__objc_selector_array		MUTEX	selector.c
+__objc_selector_hash		MUTEX	selector.c
+__objc_selector_max_index	MUTEX	selector.c	sendmsg.c runtime.h
+__objc_selector_names		MUTEX	selector.c
+__objc_thread_exit_status	SAFE	thread.c
+__objc_uninstalled_dtable	MUTEX	sendmsg.c	selector.c
+_objc_load_callback		SAFE	init.c		objc-api.h
+_objc_lookup_class		SAFE	class.c		objc-api.h
+_objc_object_alloc		SINGLE	objects.c	objc-api.h
+_objc_object_copy		SINGLE	objects.c	objc-api.h
+_objc_object_dispose		SINGLE	objects.c	objc-api.h
+frwd_sel			SAFE2	sendmsg.c
+idxsize				MUTEX	sarray.c	sendmsg.c sarray.h
+initialize_sel			SAFE2	sendmsg.c
+narrays				MUTEX	sarray.c	sendmsg.c sarray.h
+nbuckets			MUTEX	sarray.c	sendmsg.c sarray.h
+nindices			MUTEX	sarray.c	sarray.h
+previous_constructors		SAFE1	init.c
+proto_class			SAFE1	init.c
+unclaimed_categories		MUTEX	init.c
+unclaimed_proto_list		MUTEX	init.c
+uninitialized_statics		MUTEX	init.c
+
+Notes:
+1) Initialized once in unithread mode.
+2) Initialized value will always be same, guaranteed by lock on selector 
+   hash table.
+
+
+******************************************************************************
+* Frontend/Backend design:
+
+The design of the Objective-C runtime thread and mutex functions utilizes a
+frontend/backend implementation.
+
+The frontend, as characterized by the files thr.h and thr.c, is a set
+of platform independent structures and functions which represent the
+user interface.  Objective-C programs should use these structures and
+functions for their thread and mutex work if they wish to maintain a
+high degree of portability across platforms.
+
+The backend is composed of a file with the necessary code to map the ObjC
+thread and mutex to a platform specific implementation.  For example, the
+file thr-solaris.c contains the implementation for Solaris.
+
+If you are compiling libobjc as part of GCC, the thr-objc.c backend is
+always used; this backend uses GCC's gthread code.  The thread system
+is automatically configured when GCC is configured.  Important: make
+sure you configure GCC using `--enable-threads' if you want threads !
+  
+If you want to compile libobjc standalone, then you would need to
+modify the configure.in and makefiles for it; and you need to pick an
+appropriate backend file for the target platform; you make this choice
+by assigning the OBJC_THREAD_FILE make variable to the basename of the
+backend file.  For example, OBJC_THREAD_FILE=thr-posix would indicate
+that the generic posix backend file, thr-posix.c, should be compiled
+with the ObjC runtime library.  If your platform does not support
+threads then you should specify the OBJC_THREAD_FILE=thr-single
+backend file to compile the ObjC runtime library without thread or
+mutex support; note that programs which rely upon the ObjC thread and
+mutex functions will compile and link correctly but attempting to
+create a thread or mutex will result in an error.
+  
+It is questionable whether it is really necessary to have both a
+frontend and backend function for all available functionality.  On the
+one hand, it provides a clear, consistent differentiation between what
+is public and what is private with the downside of having the overhead
+of multiple functions calls.  For example, the function to have a
+thread yield the processor is objc_thread_yield; in the current
+implementation this produces a function call set:
+
+objc_thread_yield()  ->  __objc_thread_yield()  ->  system yield function
+
+This has two extra function calls over calling the platform specific function
+explicitly, but the issue is whether only the overhead of a single function
+is necessary.
+
+objc_thread_yield()  ->  system yield function
+
+This breaks the public/private dichotomy between the frontend/backend
+for the sake of efficiency.  It is possible to just use a preprocessor
+define so as to eliminate the extra function call:
+
+#define objc_thread_yield() __objc_thread_yield()
+
+This has the undesirable effect that if objc_thread_yield is actually
+turned into a function based upon future need; then ObjC programs which
+access the thread functions would need to be recompiled versus just
+being relinked.
+ 
+******************************************************************************
+* Threads:
+
+The thread system attempts to create multiple threads using whatever
+operating system or library thread support is available.  It does
+assume that all system functions are thread safe.  Notably this means
+that the system implementation of malloc and free must be thread safe.
+If a system has multiple processors, the threads are configured for
+full parallel processing.
+
+* Backend initialization functions
+
+__objc_init_thread_system(void), int
+	Initialize the thread subsystem.  Called once by __objc_exec_class.
+	Return -1 if error otherwise return 0.
+
+__objc_close_thread_system(void), int
+	Closes the thread subsystem, not currently guaranteed to be called.
+	Return -1 if error otherwise return 0.
+
+*****
+* Frontend thread functions
+* User programs should use these functions.
+
+objc_thread_detach(SEL selector, id object, id argument), objc_thread_t
+	Creates and detaches a new thread.  The new thread starts by
+	sending the given selector with a single argument to the
+	given object.
+
+objc_thread_set_priority(int priority), int
+	Sets a thread's relative priority within the program.  Valid
+	options are:
+	
+	OBJC_THREAD_INTERACTIVE_PRIORITY
+	OBJC_THREAD_BACKGROUND_PRIORITY
+	OBJC_THREAD_LOW_PRIORITY
+
+objc_thread_get_priority(void), int
+	Query a thread's priority.
+
+objc_thread_yield(void), void
+	Yields processor to another thread with equal or higher
+	priority.  It is up to the system scheduler to determine if
+	the processor is taken or not.
+
+objc_thread_exit(void), int
+	Terminates a thread.  If this is the last thread executing
+	then the program will terminate.
+
+objc_thread_id(void), int
+	Returns the current thread's id.
+
+objc_thread_set_data(void *value), int
+	Set a pointer to the thread's local storage.  Local storage is
+	thread specific.
+
+objc_thread_get_data(void), void *
+	Returns the pointer to the thread's local storage.
+
+*****
+* Backend thread functions
+* User programs should *NOT* directly call these functions.
+
+__objc_thread_detach(void (*func)(void *arg), void *arg), objc_thread_t
+	Spawns a new thread executing func, called by objc_thread_detach.
+	Return NULL if error otherwise return thread id.
+
+__objc_thread_set_priority(int priority), int
+	Set the thread's priority, called by objc_thread_set_priority.
+	Return -1 if error otherwise return 0.
+
+__objc_thread_get_priority(void), int
+	Query a thread's priority, called by objc_thread_get_priority.
+	Return -1 if error otherwise return the priority.
+
+__objc_thread_yield(void), void
+	Yields the processor, called by objc_thread_yield.
+
+__objc_thread_exit(void), int
+	Terminates the thread, called by objc_thread_exit.
+	Return -1 if error otherwise function does not return.
+
+__objc_thread_id(void), objc_thread_t
+	Returns the current thread's id, called by objc_thread_id.
+	Return -1 if error otherwise return thread id.
+
+__objc_thread_set_data(void *value), int
+	Set pointer for thread local storage, called by objc_thread_set_data.
+	Returns -1 if error otherwise return 0.
+
+__objc_thread_get_data(void), void *
+	Returns the pointer to the thread's local storage.
+	Returns NULL if error, called by objc_thread_get_data.
+
+
+******************************************************************************
+* Mutexes:
+
+Mutexes can be locked recursively.  Each locked mutex remembers
+its owner (by thread id) and how many times it has been locked.  The
+last unlock on a mutex removes the system lock and allows other
+threads to access the mutex.
+
+*****
+* Frontend mutex functions
+* User programs should use these functions.
+
+objc_mutex_allocate(void), objc_mutex_t
+	Allocates a new mutex.  Mutex is initially unlocked.
+	Return NULL if error otherwise return mutex pointer.
+
+objc_mutex_deallocate(objc_mutex_t mutex), int
+	Free a mutex.  Before freeing the mutex, makes sure that no
+	one else is using it.
+	Return -1 if error otherwise return 0.
+
+objc_mutex_lock(objc_mutex_t mutex), int
+	Locks a mutex.  As mentioned earlier, the same thread may call
+	this routine repeatedly.
+	Return -1 if error otherwise return 0.
+	
+objc_mutex_trylock(objc_mutex_t mutex), int
+	Attempts to lock a mutex.  If lock on mutex can be acquired 
+	then function operates exactly as objc_mutex_lock.
+	Return -1 if failed to acquire lock otherwise return 0.
+
+objc_mutex_unlock(objc_mutex_t mutex), int
+	Unlocks the mutex by one level.  Other threads may not acquire
+	the mutex until this thread has released all locks on it.
+	Return -1 if error otherwise return 0.
+
+*****
+* Backend mutex functions
+* User programs should *NOT* directly call these functions.
+
+__objc_mutex_allocate(objc_mutex_t mutex), int
+	Allocates a new mutex, called by objc_mutex_allocate.
+	Return -1 if error otherwise return 0.
+
+__objc_mutex_deallocate(objc_mutex_t mutex), int
+	Free a mutex, called by objc_mutex_deallocate.
+	Return -1 if error otherwise return 0.
+
+__objc_mutex_lock(objc_mutex_t mutex), int
+	Locks a mutex, called by objc_mutex_lock.
+	Return -1 if error otherwise return 0.
+	
+__objc_mutex_trylock(objc_mutex_t mutex), int
+	Attempts to lock a mutex, called by objc_mutex_trylock.
+	Return -1 if failed to acquire lock or error otherwise return 0.
+
+__objc_mutex_unlock(objc_mutex_t mutex), int
+	Unlocks the mutex, called by objc_mutex_unlock.
+	Return -1 if error otherwise return 0.
+
+******************************************************************************
+* Condition Mutexes:
+
+Mutexes can be locked recursively.  Each locked mutex remembers
+its owner (by thread id) and how many times it has been locked.  The
+last unlock on a mutex removes the system lock and allows other
+threads to access the mutex.
+
+*
+* Frontend condition mutex functions
+* User programs should use these functions.
+*
+
+objc_condition_allocate(void), objc_condition_t 
+	Allocate a condition mutex.
+	Return NULL if error otherwise return condition pointer.
+
+objc_condition_deallocate(objc_condition_t condition), int
+	Deallocate a condition. Note that this includes an implicit
+	condition_broadcast to insure that waiting threads have the 
+	opportunity to wake.  It is legal to dealloc a condition only
+	if no other thread is/will be using it. Does NOT check for
+	other threads waiting but just wakes them up.
+	Return -1 if error otherwise return 0.
+
+objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex), int
+	Wait on the condition unlocking the mutex until objc_condition_signal()
+	or objc_condition_broadcast() are called for the same condition. The
+	given mutex *must* have the depth 1 so that it can be unlocked
+	here, for someone else can lock it and signal/broadcast the condition.
+	The mutex is used to lock access to the shared data that make up the
+	"condition" predicate.
+	Return -1 if error otherwise return 0.
+	
+objc_condition_broadcast(objc_condition_t condition), int
+	Wake up all threads waiting on this condition. It is recommended that 
+	the called would lock the same mutex as the threads in
+	objc_condition_wait before changing the "condition predicate"
+	and make this call and unlock it right away after this call.
+	Return -1 if error otherwise return 0.
+
+objc_condition_signal(objc_condition_t condition), int
+	Wake up one thread waiting on this condition.
+	Return -1 if error otherwise return 0.
+
+*
+* Backend condition mutex functions
+* User programs should *NOT* directly call these functions.
+*
+
+__objc_condition_allocate(objc_condition_t condition), int
+	Allocate a condition mutex, called by objc_condition_allocate.
+	Return -1 if error otherwise return 0.
+
+__objc_condition_deallocate(objc_condition_t condition), int
+	Deallocate a condition, called by objc_condition_deallocate.
+	Return -1 if error otherwise return 0.
+
+__objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex), int
+	Wait on the condition, called by objc_condition_wait.
+	Return -1 if error otherwise return 0 when condition is met.
+	
+__objc_condition_broadcast(objc_condition_t condition), int
+	Wake up all threads waiting on this condition.
+	Called by objc_condition_broadcast.
+	Return -1 if error otherwise return 0.
+
+__objc_condition_signal(objc_condition_t condition), int
+	Wake up one thread waiting on this condition.
+	Called by objc_condition_signal.
+	Return -1 if error otherwise return 0.

Added: llvm-gcc-4.2/trunk/libobjc/THREADS.MACH
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/THREADS.MACH?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/THREADS.MACH (added)
+++ llvm-gcc-4.2/trunk/libobjc/THREADS.MACH Thu Nov  8 16:56:19 2007
@@ -0,0 +1,23 @@
+This readme refers to the file thr-mach.c.
+
+Under mach, thread priorities are kinda strange-- any given thread has
+a MAXIMUM priority and a BASE priority.  The BASE priority is the
+current priority of the thread and the MAXIMUM is the maximum possible
+priority the thread can assume.  The developer can lower, but never
+raise the maximum priority.
+
+The gcc concept of thread priorities is that they run at one of three
+levels;  interactive, background, and low.
+
+Under mach, this is translated to:
+
+interactive -- set priority to maximum
+background  -- set priority to 2/3 of maximum
+low         -- set priority to 1/3 of maximum
+
+This means that it is possible for a thread with the priority of
+interactive to actually run at a lower priority than another thread
+with a background, or even low, priority if the developer has modified
+the maximum priority.
+
+

Added: llvm-gcc-4.2/trunk/libobjc/acinclude.m4
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/acinclude.m4?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/acinclude.m4 (added)
+++ llvm-gcc-4.2/trunk/libobjc/acinclude.m4 Thu Nov  8 16:56:19 2007
@@ -0,0 +1,24 @@
+dnl Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2004
+dnl Free Software Foundation, Inc.
+dnl This file is free software; the Free Software Foundation
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl This program is distributed in the hope that it will be useful,
+dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+dnl PARTICULAR PURPOSE.
+
+m4_include(../config/acx.m4)
+m4_include(../config/no-executables.m4)
+
+m4_include(../libtool.m4)
+dnl The lines below arrange for aclocal not to bring an installed
+dnl libtool.m4 into aclocal.m4, while still arranging for automake to
+dnl add a definition of LIBTOOL to Makefile.in.
+ifelse(yes,no,[
+AC_DEFUN([AM_PROG_LIBTOOL],)
+AC_DEFUN([AC_LIBTOOL_DLOPEN],)
+AC_DEFUN([AC_LIBLTDL_CONVENIENCE],)
+AC_SUBST(LIBTOOL)
+])

Added: llvm-gcc-4.2/trunk/libobjc/aclocal.m4
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/libobjc/aclocal.m4?rev=43913&view=auto

==============================================================================
--- llvm-gcc-4.2/trunk/libobjc/aclocal.m4 (added)
+++ llvm-gcc-4.2/trunk/libobjc/aclocal.m4 Thu Nov  8 16:56:19 2007
@@ -0,0 +1,158 @@
+# generated automatically by aclocal 1.9.6 -*- Autoconf -*-
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005  Free Software Foundation, Inc.
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+
+# Copyright (C) 2001, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
+# $ac_aux_dir to `$srcdir/foo'.  In other projects, it is set to
+# `$srcdir', `$srcdir/..', or `$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory.  The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run.  This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+#    fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+#    fails if $ac_aux_dir is absolute,
+#    fails when called from a subdirectory in a VPATH build with
+#          a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir.  In an in-source build this is usually
+# harmless because $srcdir is `.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
+# and then we would define $MISSING as
+#   MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH.  The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN([AM_AUX_DIR_EXPAND],
+[dnl Rely on autoconf to set up CDPATH properly.
+AC_PREREQ([2.50])dnl
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+])
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 7
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN([AM_CONDITIONAL],
+[AC_PREREQ(2.52)dnl
+ ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
+	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+AC_SUBST([$1_TRUE])
+AC_SUBST([$1_FALSE])
+if $2; then
+  $1_TRUE=
+  $1_FALSE='#'
+else
+  $1_TRUE='#'
+  $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+  AC_MSG_ERROR([[conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.]])
+fi])])
+
+# Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
+# From Jim Meyering
+
+# Copyright (C) 1996, 1998, 2000, 2001, 2002, 2003, 2004, 2005
+# Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 4
+
+AC_DEFUN([AM_MAINTAINER_MODE],
+[AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
+  dnl maintainer-mode is disabled by default
+  AC_ARG_ENABLE(maintainer-mode,
+[  --enable-maintainer-mode  enable make rules and dependencies not useful
+			  (and sometimes confusing) to the casual installer],
+      USE_MAINTAINER_MODE=$enableval,
+      USE_MAINTAINER_MODE=no)
+  AC_MSG_RESULT([$USE_MAINTAINER_MODE])
+  AM_CONDITIONAL(MAINTAINER_MODE, [test $USE_MAINTAINER_MODE = yes])
+  MAINT=$MAINTAINER_MODE_TRUE
+  AC_SUBST(MAINT)dnl
+]
+)
+
+AU_DEFUN([jm_MAINTAINER_MODE], [AM_MAINTAINER_MODE])
+
+# Copyright (C) 1999, 2000, 2001, 2003, 2005  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# serial 3
+
+# AM_PROG_CC_C_O
+# --------------
+# Like AC_PROG_CC_C_O, but changed for automake.
+AC_DEFUN([AM_PROG_CC_C_O],
+[AC_REQUIRE([AC_PROG_CC_C_O])dnl
+AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+# FIXME: we rely on the cache variable name because
+# there is no other way.
+set dummy $CC
+ac_cc=`echo $[2] | sed ['s/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/']`
+if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" != yes"; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+])
+
+m4_include([../config/multi.m4])
+m4_include([acinclude.m4])



