[llvm-commits] [llvm-gcc-4.2] r43913 [76/80] - in /llvm-gcc-4.2/trunk: boehm-gc/ boehm-gc/Mac_files/ boehm-gc/cord/ boehm-gc/doc/ boehm-gc/include/ boehm-gc/include/private/ boehm-gc/tests/ libffi/ libffi/include/ libffi/src/ libffi/src/alpha/ libffi/src/arm/ libffi/src/cris/ libffi/src/frv/ libffi/src/ia64/ libffi/src/m32r/ libffi/src/m68k/ libffi/src/mips/ libffi/src/pa/ libffi/src/powerpc/ libffi/src/s390/ libffi/src/sh/ libffi/src/sh64/ libffi/src/sparc/ libffi/src/x86/ libffi/testsuite/ libffi/testsuite/config/ li...
Bill Wendling
isanbard at gmail.com
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 = ¤t_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 = ¤t_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 = ¤t_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 = ¤t_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 (¤t->interrupt_mutex);
+ ensure_interrupt_event_initialized (current->interrupt_event);
+ jboolean interrupted = current_obj->interrupt_flag;
+ LeaveCriticalSection (¤t->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 (¤t->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 (¤t->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 (¤t->interrupt_mutex);
+ ensure_interrupt_event_initialized (current->interrupt_event);
+ HANDLE hEvent = current->interrupt_event;
+ LeaveCriticalSection (¤t->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])
More information about the llvm-commits
mailing list