path: root/recipes/glibc/glibc-2.3.2/50_glibc232-hppa-full-nptl-2003-10-22.patch

--- glibc-2.3.2-orig-debian/elf/dynamic-link.h	2003-10-22 01:06:09.000000000 -0400
+++ glibc-2.3.2/elf/dynamic-link.h	2003-10-22 01:11:53.000000000 -0400
@@ -39,12 +39,21 @@
 elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
 		  const ElfW(Sym) *sym, const struct r_found_version *version,
 		  void *const reloc_addr);
+# if ELF_MACHINE_REL_RELATIVE_NEEDSLINKMAP
+auto void __attribute__((always_inline))
+elf_machine_rel_relative (struct link_map *map, ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
+			  void *const reloc_addr);
+auto void __attribute__((always_inline))
+elf_machine_rela_relative (struct link_map *map, ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
+			  void *const reloc_addr);
+# else
 auto void __attribute__((always_inline))
 elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
 			  void *const reloc_addr);
 auto void __attribute__((always_inline))
 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
 			   void *const reloc_addr);
+# endif
 # if ELF_MACHINE_NO_RELA || defined ELF_MACHINE_PLT_REL
 auto void __attribute__((always_inline))
 elf_machine_lazy_rel (struct link_map *map,
--- glibc-2.3.2-orig-debian/linuxthreads/attr.c	2003-10-22 01:06:10.000000000 -0400
+++ glibc-2.3.2/linuxthreads/attr.c	2003-10-22 01:07:38.000000000 -0400
@@ -450,12 +450,19 @@
 		{
 		  /* Found the entry.  Now we have the info we need.  */
 		  attr->__stacksize = rl.rlim_cur;
+#ifdef _STACK_GROWS_DOWN
 		  attr->__stackaddr = (void *) to;
-
+#else
+                  attr->__stackaddr = (void *) from;
+#endif
 		  /* The limit might be too high.  This is a bogus
 		     situation but try to avoid making it worse.  */
 		  if ((size_t) attr->__stacksize > (size_t) attr->__stackaddr)
+#ifdef _STACK_GROWS_DOWN
 		    attr->__stacksize = (size_t) attr->__stackaddr;
+#else
+                    attr->__stacksize = (size_t)(to - from);
+#endif
 
 		  /* We succeed and no need to look further.  */
 		  ret = 0;
--- glibc-2.3.2-orig-debian/linuxthreads/descr.h	2003-10-22 01:06:10.000000000 -0400
+++ glibc-2.3.2/linuxthreads/descr.h	2003-10-22 01:07:38.000000000 -0400
@@ -71,7 +71,7 @@
 /* Atomic counter made possible by compare_and_swap */
 struct pthread_atomic {
   long p_count;
-  int p_spinlock;
+  __atomic_lock_t p_spinlock;
 };
 
 
--- glibc-2.3.2-orig-debian/linuxthreads/manager.c	2003-10-22 01:06:10.000000000 -0400
+++ glibc-2.3.2/linuxthreads/manager.c	2003-10-22 01:07:38.000000000 -0400
@@ -70,8 +70,13 @@
 #else
 static inline pthread_descr thread_segment(int seg)
 {
+# ifdef _STACK_GROWS_UP
+  return (pthread_descr)(THREAD_STACK_START_ADDRESS + (seg - 1) * STACK_SIZE)
+         + 1;
+# else
   return (pthread_descr)(THREAD_STACK_START_ADDRESS - (seg - 1) * STACK_SIZE)
          - 1;
+# endif
 }
 #endif
 
--- glibc-2.3.2-orig-debian/linuxthreads/oldsemaphore.c	2003-10-22 01:03:57.000000000 -0400
+++ glibc-2.3.2/linuxthreads/oldsemaphore.c	2003-10-22 01:07:38.000000000 -0400
@@ -31,7 +31,7 @@
 
 typedef struct {
     long int sem_status;
-    int sem_spinlock;
+    __atomic_lock_t sem_spinlock;
 } old_sem_t;
 
 extern int __old_sem_init (old_sem_t *__sem, int __pshared, unsigned int __value);
--- glibc-2.3.2-orig-debian/linuxthreads/pt-machine.c	2003-10-22 01:03:57.000000000 -0400
+++ glibc-2.3.2/linuxthreads/pt-machine.c	2003-10-22 01:07:38.000000000 -0400
@@ -19,7 +19,9 @@
 
 #define PT_EI
 
-extern long int testandset (int *spinlock);
+#include <pthread.h>
+
+extern long int testandset (__atomic_lock_t *spinlock);
 extern int __compare_and_swap (long int *p, long int oldval, long int newval);
 
 #include <pt-machine.h>
--- glibc-2.3.2-orig-debian/linuxthreads/pthread.c	2003-10-22 01:06:16.000000000 -0400
+++ glibc-2.3.2/linuxthreads/pthread.c	2003-10-22 01:07:38.000000000 -0400
@@ -300,9 +300,9 @@
   pthread_descr self;
 
   /* First of all init __pthread_handles[0] and [1] if needed.  */
-# if __LT_SPINLOCK_INIT != 0
-  __pthread_handles[0].h_lock = __LOCK_INITIALIZER;
-  __pthread_handles[1].h_lock = __LOCK_INITIALIZER;
+# ifdef __LT_INITIALIZER_NOT_ZERO
+  __pthread_handles[0].h_lock = __LOCK_ALT_INITIALIZER;
+  __pthread_handles[1].h_lock = __LOCK_ALT_INITIALIZER;
 # endif
 # ifndef SHARED
   /* Unlike in the dynamically linked case the dynamic linker has not
@@ -370,7 +370,7 @@
 # endif
   /* self->p_start_args need not be initialized, it's all zero.  */
   self->p_userstack = 1;
-# if __LT_SPINLOCK_INIT != 0
+# ifdef __LT_INITIALIZER_NOT_ZERO 
   self->p_resume_count = (struct pthread_atomic) __ATOMIC_INITIALIZER;
 # endif
   self->p_alloca_cutoff = __MAX_ALLOCA_CUTOFF;
@@ -384,9 +384,9 @@
 #else  /* USE_TLS */
 
   /* First of all init __pthread_handles[0] and [1].  */
-# if __LT_SPINLOCK_INIT != 0
-  __pthread_handles[0].h_lock = __LOCK_INITIALIZER;
-  __pthread_handles[1].h_lock = __LOCK_INITIALIZER;
+# ifdef __LT_INITIALIZER_NOT_ZERO
+  __pthread_handles[0].h_lock = __LOCK_ALT_INITIALIZER;
+  __pthread_handles[1].h_lock = __LOCK_ALT_INITIALIZER;
 # endif
   __pthread_handles[0].h_descr = &__pthread_initial_thread;
   __pthread_handles[1].h_descr = &__pthread_manager_thread;
@@ -893,7 +893,11 @@
   /* __pthread_handles[0] is the initial thread, __pthread_handles[1] is
      the manager threads handled specially in thread_self(), so start at 2 */
   h = __pthread_handles + 2;
+# ifdef _STACK_GROWS_UP
+  while (! (sp >= (char *) h->h_descr && sp < h->h_descr->p_guardaddr)) h++;
+# else
   while (! (sp <= (char *) h->h_descr && sp >= h->h_bottom)) h++;
+# endif
   return h->h_descr;
 }
 
@@ -908,11 +912,22 @@
     return manager_thread;
   h = __pthread_handles + 2;
 # ifdef USE_TLS
+#  ifdef _STACK_GROWS_UP
+  while (h->h_descr == NULL
+	 || ! (sp >= h->h_descr->p_stackaddr && 
+	       sp < h->h_descr->p_guardaddr))
+#  else
   while (h->h_descr == NULL
-	 || ! (sp <= (char *) h->h_descr->p_stackaddr && sp >= h->h_bottom))
+	 || ! (sp <= h->h_descr->p_stackaddr && 
+	       sp >= h->h_bottom))
+#  endif
     h++;
 # else
+#  ifdef _STACK_GROWS_UP
+  while (! (sp >= (char *) h->h_descr && sp < h->h_descr->p_guardaddr))
+#  else
   while (! (sp <= (char *) h->h_descr && sp >= h->h_bottom))
+#  endif
     h++;
 # endif
   return h->h_descr;
--- glibc-2.3.2-orig-debian/linuxthreads/spinlock.c	2003-10-22 01:03:57.000000000 -0400
+++ glibc-2.3.2/linuxthreads/spinlock.c	2003-10-22 01:07:38.000000000 -0400
@@ -24,9 +24,9 @@
 #include "spinlock.h"
 #include "restart.h"
 
-static void __pthread_acquire(int * spinlock);
+static void __pthread_acquire(__atomic_lock_t * spinlock);
 
-static inline void __pthread_release(int * spinlock)
+static inline void __pthread_release(__atomic_lock_t * spinlock)
 {
   WRITE_MEMORY_BARRIER();
   *spinlock = __LT_SPINLOCK_INIT;
@@ -269,11 +269,11 @@
 struct wait_node {
   struct wait_node *next;	/* Next node in null terminated linked list */
   pthread_descr thr;		/* The thread waiting with this node */
-  int abandoned;		/* Atomic flag */
+  __atomic_lock_t abandoned;	/* Atomic flag */
 };
 
 static long wait_node_free_list;
-static int wait_node_free_list_spinlock;
+__pthread_lock_define_initialized(static, wait_node_free_list_spinlock);
 
 /* Allocate a new node from the head of the free list using an atomic
    operation, or else using malloc if that list is empty.  A fundamental
@@ -376,7 +376,7 @@
       if (self == NULL)
 	self = thread_self();
 
-      wait_node.abandoned = 0;
+      wait_node.abandoned = __LT_SPINLOCK_INIT;
       wait_node.next = (struct wait_node *) lock->__status;
       wait_node.thr = self;
       lock->__status = (long) &wait_node;
@@ -402,7 +402,7 @@
       wait_node.thr = self;
       newstatus = (long) &wait_node;
     }
-    wait_node.abandoned = 0;
+    wait_node.abandoned = __LT_SPINLOCK_INIT;
     wait_node.next = (struct wait_node *) oldstatus;
     /* Make sure the store in wait_node.next completes before performing
        the compare-and-swap */
@@ -451,7 +451,7 @@
       if (self == NULL)
 	self = thread_self();
 
-      p_wait_node->abandoned = 0;
+      p_wait_node->abandoned = __LT_SPINLOCK_INIT;
       p_wait_node->next = (struct wait_node *) lock->__status;
       p_wait_node->thr = self;
       lock->__status = (long) p_wait_node;
@@ -474,7 +474,7 @@
       p_wait_node->thr = self;
       newstatus = (long) p_wait_node;
     }
-    p_wait_node->abandoned = 0;
+    p_wait_node->abandoned = __LT_SPINLOCK_INIT;
     p_wait_node->next = (struct wait_node *) oldstatus;
     /* Make sure the store in wait_node.next completes before performing
        the compare-and-swap */
@@ -574,7 +574,7 @@
     while (p_node != (struct wait_node *) 1) {
       int prio;
 
-      if (p_node->abandoned) {
+      if (lock_held(&p_node->abandoned)) {
 	/* Remove abandoned node. */
 #if defined TEST_FOR_COMPARE_AND_SWAP
 	if (!__pthread_has_cas)
@@ -662,7 +662,7 @@
 #if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
 
 int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
-                               int * spinlock)
+                               __atomic_lock_t * spinlock)
 {
   int res;
 
@@ -699,7 +699,7 @@
    - When nanosleep() returns, we try again, doing MAX_SPIN_COUNT
      sched_yield(), then sleeping again if needed. */
 
-static void __pthread_acquire(int * spinlock)
+static void __pthread_acquire(__atomic_lock_t * spinlock)	
 {
   int cnt = 0;
   struct timespec tm;
--- glibc-2.3.2-orig-debian/linuxthreads/spinlock.h	2003-10-22 01:06:10.000000000 -0400
+++ glibc-2.3.2/linuxthreads/spinlock.h	2003-10-22 01:07:38.000000000 -0400
@@ -33,14 +33,28 @@
 #endif
 #endif
 
+/* Define lock_held for all arches that don't need a modified copy. */
+#ifndef __LT_INITIALIZER_NOT_ZERO
+# define lock_held(p) *(p)
+#endif
+
+/* Initliazers for possibly complex structures */
+#ifdef __LT_INITIALIZER_NOT_ZERO
+# define __pthread_lock_define_initialized(CLASS,NAME) \
+	CLASS __atomic_lock_t NAME = __LT_SPINLOCK_ALT_INIT
+#else
+# define __pthread_lock_define_initialized(CLASS,NAME) \
+	CLASS __atomic_lock_t NAME
+#endif
+
 #if defined(TEST_FOR_COMPARE_AND_SWAP)
 
 extern int __pthread_has_cas;
 extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
-                                      int * spinlock);
+                                      __atomic_lock_t * spinlock);
 
 static inline int compare_and_swap(long * ptr, long oldval, long newval,
-                                   int * spinlock)
+                                   __atomic_lock_t * spinlock)
 {
   if (__builtin_expect (__pthread_has_cas, 1))
     return __compare_and_swap(ptr, oldval, newval);
@@ -58,7 +72,7 @@
 
 static inline int
 compare_and_swap_with_release_semantics (long * ptr, long oldval,
-					 long newval, int * spinlock)
+					 long newval, __atomic_lock_t * spinlock)
 {
   return __compare_and_swap_with_release_semantics (ptr, oldval,
 						    newval);
@@ -67,7 +81,7 @@
 #endif
 
 static inline int compare_and_swap(long * ptr, long oldval, long newval,
-                                   int * spinlock)
+                                   __atomic_lock_t * spinlock)
 {
   return __compare_and_swap(ptr, oldval, newval);
 }
@@ -75,10 +89,10 @@
 #else
 
 extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
-                                      int * spinlock);
+                                      __atomic_lock_t * spinlock);
 
 static inline int compare_and_swap(long * ptr, long oldval, long newval,
-                                   int * spinlock)
+                                   __atomic_lock_t * spinlock)
 {
   return __pthread_compare_and_swap(ptr, oldval, newval, spinlock);
 }
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/hppa/pspinlock.c	2003-10-22 01:03:57.000000000 -0400
+++ glibc-2.3.2/linuxthreads/sysdeps/hppa/pspinlock.c	2003-10-22 01:07:38.000000000 -0400
@@ -24,13 +24,10 @@
 int
 __pthread_spin_lock (pthread_spinlock_t *lock)
 {
-  unsigned int val;
+  volatile unsigned int *addr = __ldcw_align (lock);
 
-  do
-    asm volatile ("ldcw %1,%0"
-		  : "=r" (val), "=m" (*lock)
-		  : "m" (*lock));
-  while (!val);
+  while (__ldcw (addr) == 0)
+    while (*addr == 0) ;
 
   return 0;
 }
@@ -40,13 +37,9 @@
 int
 __pthread_spin_trylock (pthread_spinlock_t *lock)
 {
-  unsigned int val;
+  volatile unsigned int *a = __ldcw_align (lock);
 
-  asm volatile ("ldcw %1,%0"
-		: "=r" (val), "=m" (*lock)
-		: "m" (*lock));
-
-  return val ? 0 : EBUSY;
+  return __ldcw (a) ? 0 : EBUSY;
 }
 weak_alias (__pthread_spin_trylock, pthread_spin_trylock)
 
@@ -54,7 +47,9 @@
 int
 __pthread_spin_unlock (pthread_spinlock_t *lock)
 {
-  *lock = 1;
+  volatile unsigned int *a = __ldcw_align (lock);
+
+  *a = 1;
   return 0;
 }
 weak_alias (__pthread_spin_unlock, pthread_spin_unlock)
@@ -66,7 +61,9 @@
   /* We can ignore the `pshared' parameter.  Since we are busy-waiting
      all processes which can access the memory location `lock' points
      to can use the spinlock.  */
-  *lock = 1;
+  volatile unsigned int *a = __ldcw_align (lock);
+
+  *a = 1;
   return 0;
 }
 weak_alias (__pthread_spin_init, pthread_spin_init)
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/hppa/pt-machine.h	2003-10-22 01:06:10.000000000 -0400
+++ glibc-2.3.2/linuxthreads/sysdeps/hppa/pt-machine.h	2003-10-22 01:12:51.000000000 -0400
@@ -22,41 +22,97 @@
 #ifndef _PT_MACHINE_H
 #define _PT_MACHINE_H   1
 
+#include <sys/types.h>
 #include <bits/initspin.h>
 
 #ifndef PT_EI
 # define PT_EI extern inline __attribute__ ((always_inline))
 #endif
 
-extern long int testandset (int *spinlock);
-extern int __compare_and_swap (long int *p, long int oldval, long int newval);
+extern inline long int testandset (__atomic_lock_t *spinlock);
+extern inline int __compare_and_swap (long int *p, long int oldval, long int newval);
+extern inline int lock_held (__atomic_lock_t *spinlock); 
+extern inline int __load_and_clear (__atomic_lock_t *spinlock);
 
 /* Get some notion of the current stack.  Need not be exactly the top
    of the stack, just something somewhere in the current frame.  */
 #define CURRENT_STACK_FRAME  stack_pointer
 register char * stack_pointer __asm__ ("%r30");
 
+/* Get/Set thread-specific pointer.  We have to call into the kernel to
+ * modify it, but we can read it in user mode.  */
+
+#define THREAD_SELF __get_cr27()
+
+static inline struct _pthread_descr_struct * __get_cr27(void)
+{
+	long cr27;
+	asm("mfctl %%cr27, %0" : "=r" (cr27) : );
+	return (struct _pthread_descr_struct *) cr27;
+}
+
+#define INIT_THREAD_SELF(descr, nr) __set_cr27(descr)
+
+static inline void __set_cr27(struct _pthread_descr_struct * cr27)
+{
+	asm(
+		"ble	0xe0(%%sr2, %%r0)\n\t"
+		"copy	%0, %%r26"
+	 : : "r" (cr27) : "r26" );
+}
+
+/* We want the OS to assign stack addresses.  */
+#define FLOATING_STACKS	1
+#define ARCH_STACK_MAX_SIZE	8*1024*1024
 
 /* The hppa only has one atomic read and modify memory operation,
    load and clear, so hppa spinlocks must use zero to signify that
-   someone is holding the lock.  */
+   someone is holding the lock.  The address used for the ldcw
+   semaphore must be 16-byte aligned.  */
+#define __ldcw(a) ({ \
+  unsigned int __ret;							\
+  __asm__ __volatile__("ldcw 0(%2),%0"					\
+                      : "=r" (__ret), "=m" (*(a)) : "r" (a));		\
+  __ret;								\
+})
+
+/* Because malloc only guarantees 8-byte alignment for malloc'd data,
+   and GCC only guarantees 8-byte alignment for stack locals, we can't
+   be assured of 16-byte alignment for atomic lock data even if we
+   specify "__attribute ((aligned(16)))" in the type declaration.  So,
+   we use a struct containing an array of four ints for the atomic lock
+   type and dynamically select the 16-byte aligned int from the array
+   for the semaphore.  */
+#define __PA_LDCW_ALIGNMENT 16
+#define __ldcw_align(a) ({ \
+  volatile unsigned int __ret = (unsigned int) a;			\
+  if ((__ret & ~(__PA_LDCW_ALIGNMENT - 1)) < (unsigned int) a)		\
+    __ret = (__ret & ~(__PA_LDCW_ALIGNMENT - 1)) + __PA_LDCW_ALIGNMENT; \
+  (unsigned int *) __ret;						\
+})
 
-#define xstr(s) str(s)
-#define str(s) #s
 /* Spinlock implementation; required.  */
-PT_EI long int
-testandset (int *spinlock)
+PT_EI int
+__load_and_clear (__atomic_lock_t *spinlock)
 {
-  int ret;
+  volatile unsigned int *a = __ldcw_align (spinlock);
 
-  __asm__ __volatile__(
-       "ldcw 0(%2),%0"
-       : "=r"(ret), "=m"(*spinlock)
-       : "r"(spinlock));
+  return __ldcw (a);
+}
 
-  return ret == 0;
+/* Emulate testandset */
+PT_EI long int
+testandset (__atomic_lock_t *spinlock)
+{
+  return (__load_and_clear(spinlock) == 0);
 }
-#undef str
-#undef xstr
 
+PT_EI int
+lock_held (__atomic_lock_t *spinlock)
+{
+  volatile unsigned int *a = __ldcw_align (spinlock);
+
+  return *a == 0;
+}
+		
 #endif /* pt-machine.h */
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/hppa/pt-machine.h.rej	1969-12-31 19:00:00.000000000 -0500
+++ glibc-2.3.2/linuxthreads/sysdeps/hppa/pt-machine.h.rej	2003-10-22 01:07:38.000000000 -0400
@@ -0,0 +1,153 @@
+***************
+*** 1,6 ****
+  /* Machine-dependent pthreads configuration and inline functions.
+     hppa version.
+-    Copyright (C) 2000, 2002 Free Software Foundation, Inc.
+     This file is part of the GNU C Library.
+     Contributed by Richard Henderson <rth@tamu.edu>.
+  
+--- 1,6 ----
+  /* Machine-dependent pthreads configuration and inline functions.
+     hppa version.
++    Copyright (C) 2000, 2002, 2003 Free Software Foundation, Inc.
+     This file is part of the GNU C Library.
+     Contributed by Richard Henderson <rth@tamu.edu>.
+  
+***************
+*** 22,62 ****
+  #ifndef _PT_MACHINE_H
+  #define _PT_MACHINE_H   1
+  
+  #include <bits/initspin.h>
+  
+  #ifndef PT_EI
+  # define PT_EI extern inline
+  #endif
+  
+- extern long int testandset (int *spinlock);
+- extern int __compare_and_swap (long int *p, long int oldval, long int newval);
+  
+  /* Get some notion of the current stack.  Need not be exactly the top
+     of the stack, just something somewhere in the current frame.  */
+  #define CURRENT_STACK_FRAME  stack_pointer
+  register char * stack_pointer __asm__ ("%r30");
+  
+- 
+  /* The hppa only has one atomic read and modify memory operation,
+     load and clear, so hppa spinlocks must use zero to signify that
+-    someone is holding the lock.  */
+- 
+- #define xstr(s) str(s)
+- #define str(s) #s
+  /* Spinlock implementation; required.  */
+  PT_EI long int
+- testandset (int *spinlock)
+  {
+-   int ret;
+- 
+-   __asm__ __volatile__(
+-        "ldcw 0(%2),%0"
+-        : "=r"(ret), "=m"(*spinlock)
+-        : "r"(spinlock));
+- 
+-   return ret == 0;
+  }
+- #undef str
+- #undef xstr
+- 
+  #endif /* pt-machine.h */
+--- 22,115 ----
+  #ifndef _PT_MACHINE_H
+  #define _PT_MACHINE_H   1
+  
++ #include <sys/types.h>
+  #include <bits/initspin.h>
+  
+  #ifndef PT_EI
+  # define PT_EI extern inline
+  #endif
+  
++ extern inline long int testandset (__atomic_lock_t *spinlock);
++ extern inline int __compare_and_swap (long int *p, long int oldval, long int newval);
++ extern inline int lock_held (__atomic_lock_t *spinlock); 
++ extern inline int __load_and_clear (__atomic_lock_t *spinlock);
+  
+  /* Get some notion of the current stack.  Need not be exactly the top
+     of the stack, just something somewhere in the current frame.  */
+  #define CURRENT_STACK_FRAME  stack_pointer
+  register char * stack_pointer __asm__ ("%r30");
+  
++ /* Get/Set thread-specific pointer.  We have to call into the kernel to
++    modify it, but we can read it in user mode.  */
++  
++ #define THREAD_SELF __get_cr27()
++  
++ static inline struct _pthread_descr_struct * __get_cr27(void)
++ {
++   long cr27;
++   asm("mfctl %%cr27, %0" : "=r" (cr27) : );
++   return (struct _pthread_descr_struct *) cr27;
++ }
++  
++ #define INIT_THREAD_SELF(descr, nr) __set_cr27(descr)
++  
++ static inline void __set_cr27(struct _pthread_descr_struct * cr27)
++ {
++   asm(	"	ble 0xe0(%%sr2, %%r0)\n"
++ 	"	copy %0,%%r26"
++ 	: : "r" (cr27) : "r26" );
++ }
++  
++ /* We want the OS to assign stack addresses.  */
++ #define FLOATING_STACKS	1
++ #define ARCH_STACK_MAX_SIZE	8*1024*1024
++  
+  /* The hppa only has one atomic read and modify memory operation,
+     load and clear, so hppa spinlocks must use zero to signify that
++    someone is holding the lock.  The address used for the ldcw
++    semaphore must be 16-byte aligned.  */
++ #define __ldcw(a) ({ \
++   unsigned int __ret;							\
++   __asm__ __volatile__("ldcw 0(%2),%0"					\
++                       : "=r" (__ret), "=m" (*(a)) : "r" (a));		\
++   __ret;								\
++ })
++ 
++ /* Because malloc only guarantees 8-byte alignment for malloc'd data,
++    and GCC only guarantees 8-byte alignment for stack locals, we can't
++    be assured of 16-byte alignment for atomic lock data even if we
++    specify "__attribute ((aligned(16)))" in the type declaration.  So,
++    we use a struct containing an array of four ints for the atomic lock
++    type and dynamically select the 16-byte aligned int from the array
++    for the semaphore.  */
++ #define __PA_LDCW_ALIGNMENT 16
++ #define __ldcw_align(a) ({ \
++   volatile unsigned int __ret = (unsigned int) a;			\
++   if ((__ret & ~(__PA_LDCW_ALIGNMENT - 1)) < (unsigned int) a)		\
++     __ret = (__ret & ~(__PA_LDCW_ALIGNMENT - 1)) + __PA_LDCW_ALIGNMENT; \
++   (unsigned int *) __ret;						\
++ })
++   
+  /* Spinlock implementation; required.  */
++ PT_EI int
++ __load_and_clear (__atomic_lock_t *spinlock)
++ {
++   volatile unsigned int *a = __ldcw_align (spinlock);
++   return __ldcw (a);
++ }
++   
++ /* Emulate testandset */
+  PT_EI long int
++ testandset (__atomic_lock_t *spinlock)
+  {
++   return (__load_and_clear(spinlock) == 0);
+  }
++   
++ PT_EI int
++ lock_held (__atomic_lock_t *spinlock)
++ {
++   volatile unsigned int *a = __ldcw_align (spinlock);
++   return *a == 0;
++ }
++ 	
+  #endif /* pt-machine.h */
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/pthread/bits/libc-lock.h	2003-10-22 01:06:16.000000000 -0400
+++ glibc-2.3.2/linuxthreads/sysdeps/pthread/bits/libc-lock.h	2003-10-22 01:07:38.000000000 -0400
@@ -71,12 +71,12 @@
    initialized locks must be set to one due to the lack of normal
    atomic operations.) */
 
-#if __LT_SPINLOCK_INIT == 0
+#ifdef __LT_INITIALIZER_NOT_ZERO
 #  define __libc_lock_define_initialized(CLASS,NAME) \
-  CLASS __libc_lock_t NAME;
+  CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER;
 #else
 #  define __libc_lock_define_initialized(CLASS,NAME) \
-  CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER;
+  CLASS __libc_lock_t NAME;
 #endif
 
 #define __libc_rwlock_define_initialized(CLASS,NAME) \
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/pthread/bits/pthreadtypes.h	2003-10-22 01:03:57.000000000 -0400
+++ glibc-2.3.2/linuxthreads/sysdeps/pthread/bits/pthreadtypes.h	2003-10-22 01:07:38.000000000 -0400
@@ -22,12 +22,14 @@
 #define __need_schedparam
 #include <bits/sched.h>
 
+typedef int __atomic_lock_t;
+
 /* Fast locks (not abstract because mutexes and conditions aren't abstract). */
 struct _pthread_fastlock
 {
-  long int __status;   /* "Free" or "taken" or head of waiting list */
-  int __spinlock;      /* Used by compare_and_swap emulation. Also,
-			  adaptive SMP lock stores spin count here. */
+  long int __status;		/* "Free" or "taken" or head of waiting list */
+  __atomic_lock_t __spinlock;	/* Used by compare_and_swap emulation. Also,
+				   adaptive SMP lock stores spin count here. */
 };
 
 #ifndef _PTHREAD_DESCR_DEFINED
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/unix/sysv/linux/hppa/bits/initspin.h	2003-10-22 01:03:57.000000000 -0400
+++ glibc-2.3.2/linuxthreads/sysdeps/unix/sysv/linux/hppa/bits/initspin.h	2003-10-22 01:07:38.000000000 -0400
@@ -19,9 +19,23 @@
 
 /* Initial value of a spinlock.  PA-RISC only implements atomic load
    and clear so this must be non-zero. */
-#define __LT_SPINLOCK_INIT 1
+#define __LT_SPINLOCK_INIT ((__atomic_lock_t) { { 1, 1, 1, 1 } })
+
+/* Initialize global spinlocks without cast, generally macro wrapped */
+#define __LT_SPINLOCK_ALT_INIT { { 1, 1, 1, 1 } }
+
+/* Macros for lock initializers, not using the above definition.
+   The above definition is not used in the case that static initializers
+   use this value. */
+#define __LOCK_INITIALIZER { __LT_SPINLOCK_ALT_INIT, 0 }
+
+/* Used to initialize _pthread_fastlock's in non-static case */
+#define __LOCK_ALT_INITIALIZER ((struct _pthread_fastlock){ __LT_SPINLOCK_INIT, 0 })
+
+/* Used in pthread_atomic initialization */
+#define __ATOMIC_INITIALIZER { 0, __LT_SPINLOCK_ALT_INIT }
+
+/* Tell the rest of the code that the initializer is non-zero without
+   explaining it's internal structure */
+#define __LT_INITIALIZER_NOT_ZERO
 
-/* Macros for lock initializers, using the above definition. */
-#define __LOCK_INITIALIZER { 0, __LT_SPINLOCK_INIT }
-#define __ALT_LOCK_INITIALIZER { 0, __LT_SPINLOCK_INIT }
-#define __ATOMIC_INITIALIZER { 0, __LT_SPINLOCK_INIT }
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/unix/sysv/linux/hppa/bits/pthreadtypes.h	1969-12-31 19:00:00.000000000 -0500
+++ glibc-2.3.2/linuxthreads/sysdeps/unix/sysv/linux/hppa/bits/pthreadtypes.h	2003-10-22 01:07:38.000000000 -0400
@@ -0,0 +1,160 @@
+/* Linuxthreads - a simple clone()-based implementation of Posix        */
+/* threads for Linux.                                                   */
+/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
+/*                                                                      */
+/* This program is free software; you can redistribute it and/or        */
+/* modify it under the terms of the GNU Library 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 Library General Public License for more details.                 */
+
+#if !defined _BITS_TYPES_H && !defined _PTHREAD_H
+# error "Never include <bits/pthreadtypes.h> directly; use <sys/types.h> instead."
+#endif
+
+#ifndef _BITS_PTHREADTYPES_H
+#define _BITS_PTHREADTYPES_H	1
+
+#define __need_schedparam
+#include <bits/sched.h>
+
+/* We need 128-bit alignment for the ldcw semaphore.  At most, we are
+   assured of 64-bit alignment for stack locals and malloc'd data.  Thus,
+   we use a struct with four ints for the atomic lock type.  The locking
+   code will figure out which of the four to use for the ldcw semaphore.  */
+typedef volatile struct {
+  int lock[4];
+} __attribute__ ((aligned(16))) __atomic_lock_t;
+
+/* Fast locks (not abstract because mutexes and conditions aren't abstract). */
+struct _pthread_fastlock
+{
+  __atomic_lock_t __spinlock;	/* Used by compare_and_swap emulation.  Also,
+				   adaptive SMP lock stores spin count here. */
+  long int __status;		/* "Free" or "taken" or head of waiting list */
+};
+
+#ifndef _PTHREAD_DESCR_DEFINED
+/* Thread descriptors */
+typedef struct _pthread_descr_struct *_pthread_descr;
+# define _PTHREAD_DESCR_DEFINED
+#endif
+
+
+/* Attributes for threads.  */
+typedef struct __pthread_attr_s
+{
+  int __detachstate;
+  int __schedpolicy;
+  struct __sched_param __schedparam;
+  int __inheritsched;
+  int __scope;
+  size_t __guardsize;
+  int __stackaddr_set;
+  void *__stackaddr;
+  size_t __stacksize;
+} pthread_attr_t;
+
+
+/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
+
+#ifdef __GLIBC_HAVE_LONG_LONG
+__extension__ typedef long long __pthread_cond_align_t;
+#else
+typedef long __pthread_cond_align_t;
+#endif
+
+typedef struct
+{
+  struct _pthread_fastlock __c_lock; /* Protect against concurrent access */
+  _pthread_descr __c_waiting;        /* Threads waiting on this condition */
+  char __padding[48 - sizeof (struct _pthread_fastlock)
+		 - sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
+  __pthread_cond_align_t __align;
+} pthread_cond_t;
+
+
+/* Attribute for conditionally variables.  */
+typedef struct
+{
+  int __dummy;
+} pthread_condattr_t;
+
+/* Keys for thread-specific data */
+typedef unsigned int pthread_key_t;
+
+
+/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER).  */
+/* (The layout is unnatural to maintain binary compatibility
+    with earlier releases of LinuxThreads.) */
+typedef struct
+{
+  int __m_reserved;               /* Reserved for future use */
+  int __m_count;                  /* Depth of recursive locking */
+  _pthread_descr __m_owner;       /* Owner thread (if recursive or errcheck) */
+  int __m_kind;                   /* Mutex kind: fast, recursive or errcheck */
+  struct _pthread_fastlock __m_lock; /* Underlying fast lock */
+} pthread_mutex_t;
+
+
+/* Attribute for mutex.  */
+typedef struct
+{
+  int __mutexkind;
+} pthread_mutexattr_t;
+
+
+/* Once-only execution */
+typedef int pthread_once_t;
+
+
+#ifdef __USE_UNIX98
+/* Read-write locks.  */
+typedef struct _pthread_rwlock_t
+{
+  struct _pthread_fastlock __rw_lock; /* Lock to guarantee mutual exclusion */
+  int __rw_readers;                   /* Number of readers */
+  _pthread_descr __rw_writer;         /* Identity of writer, or NULL if none */
+  _pthread_descr __rw_read_waiting;   /* Threads waiting for reading */
+  _pthread_descr __rw_write_waiting;  /* Threads waiting for writing */
+  int __rw_kind;                      /* Reader/Writer preference selection */
+  int __rw_pshared;                   /* Shared between processes or not */
+} pthread_rwlock_t;
+
+
+/* Attribute for read-write locks.  */
+typedef struct
+{
+  int __lockkind;
+  int __pshared;
+} pthread_rwlockattr_t;
+#endif
+
+#ifdef __USE_XOPEN2K
+/* POSIX spinlock data type.  */
+typedef __atomic_lock_t pthread_spinlock_t;
+
+/* POSIX barrier. */
+typedef struct {
+  struct _pthread_fastlock __ba_lock; /* Lock to guarantee mutual exclusion */
+  int __ba_required;                  /* Threads needed for completion */
+  int __ba_present;                   /* Threads waiting */
+  _pthread_descr __ba_waiting;        /* Queue of waiting threads */
+} pthread_barrier_t;
+
+/* barrier attribute */
+typedef struct {
+  int __pshared;
+} pthread_barrierattr_t;
+
+#endif
+
+
+/* Thread identifiers */
+typedef unsigned long int pthread_t;
+
+#endif	/* bits/pthreadtypes.h */
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/unix/sysv/linux/hppa/malloc-machine.h	1969-12-31 19:00:00.000000000 -0500
+++ glibc-2.3.2/linuxthreads/sysdeps/unix/sysv/linux/hppa/malloc-machine.h	2003-10-22 01:07:38.000000000 -0400
@@ -0,0 +1,73 @@
+/* HP-PARISC macro definitions for mutexes, thread-specific data 
+   and parameters for malloc.
+   Copyright (C) 2003 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Carlos O'Donell <carlos@baldric.uwo.ca>, 2003.
+   
+   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., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _MALLOC_MACHINE_H
+#define _MALLOC_MACHINE_H
+
+#undef thread_atfork_static
+
+#include <atomic.h>
+#include <bits/libc-lock.h>
+
+__libc_lock_define (typedef, mutex_t)
+
+/* Since our lock structure does not tolerate being initialized to zero, we must
+   modify the standard function calls made by malloc */
+#  define mutex_init(m)		\
+	__libc_maybe_call (__pthread_mutex_init, (m, NULL), \
+		(((m)->__m_lock.__spinlock = __LT_SPINLOCK_INIT),(*(int *)(m))) )
+#  define mutex_lock(m)		\
+	__libc_maybe_call (__pthread_mutex_lock, (m), \
+			(__load_and_clear(&((m)->__m_lock.__spinlock)), 0))
+#  define mutex_trylock(m)	\
+	__libc_maybe_call (__pthread_mutex_trylock, (m), \
+			(*(int *)(m) ? 1 : (__load_and_clear(&((m)->__m_lock.__spinlock)), 0)))
+#  define mutex_unlock(m)	\
+	__libc_maybe_call (__pthread_mutex_unlock, (m), \
+			(((m)->__m_lock.__spinlock = __LT_SPINLOCK_INIT), (*(int *)(m))) )
+	
+/* This is defined by newer gcc version unique for each module.  */
+extern void *__dso_handle __attribute__ ((__weak__));
+
+#include <fork.h>
+
+#ifdef SHARED
+# define thread_atfork(prepare, parent, child) \
+   __register_atfork (prepare, parent, child, __dso_handle)
+#else
+# define thread_atfork(prepare, parent, child) \
+   __register_atfork (prepare, parent, child,				      \
+		      &__dso_handle == NULL ? NULL : __dso_handle)
+#endif
+
+/* thread specific data for glibc */
+
+#include <bits/libc-tsd.h>
+
+typedef int tsd_key_t[1];	/* no key data structure, libc magic does it */
+__libc_tsd_define (static, MALLOC)	/* declaration/common definition */
+#define tsd_key_create(key, destr)	((void) (key))
+#define tsd_setspecific(key, data)	__libc_tsd_set (MALLOC, (data))
+#define tsd_getspecific(key, vptr)	((vptr) = __libc_tsd_get (MALLOC))
+
+#include <sysdeps/generic/malloc-machine.h>
+
+#endif /* !defined(_MALLOC_MACHINE_H) */
--- glibc-2.3.2-orig-debian/linuxthreads/sysdeps/unix/sysv/linux/hppa/sysdep-cancel.h	1969-12-31 19:00:00.000000000 -0500
+++ glibc-2.3.2/linuxthreads/sysdeps/unix/sysv/linux/hppa/sysdep-cancel.h	2003-10-22 01:07:38.000000000 -0400
@@ -0,0 +1,190 @@
+/* Copyright (C) 2003 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Carlos O'Donell <carlos@baldric.uwo.ca>, 2003.
+
+   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., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <sysdep.h>
+#ifndef __ASSEMBLER__
+# include <linuxthreads/internals.h>
+#endif
+
+#if !defined NOT_IN_libc || defined IS_IN_libpthread || defined IS_IN_librt
+
+# ifndef NO_ERROR
+#  define NO_ERROR -0x1000
+# endif
+
+# undef PSEUDO
+# define PSEUDO(name, syscall_name, args)				\
+  ENTRY (name)								\
+    SINGLE_THREAD_P					ASM_LINE_SEP	\
+    cmpib,<> 0,%ret0,Lpseudo_cancel			ASM_LINE_SEP	\
+    nop							ASM_LINE_SEP	\
+    DO_CALL(syscall_name, args)				ASM_LINE_SEP	\
+    /* DONE! */						ASM_LINE_SEP	\
+    bv 0(2)						ASM_LINE_SEP	\
+    nop							ASM_LINE_SEP	\
+  Lpseudo_cancel:					ASM_LINE_SEP	\
+    /* store return ptr */				ASM_LINE_SEP	\
+    stw %rp, -20(%sr0,%sp)				ASM_LINE_SEP	\
+    /* save syscall args */				ASM_LINE_SEP	\
+    PUSHARGS_##args /* MACRO */				ASM_LINE_SEP	\
+    STW_PIC						ASM_LINE_SEP	\
+    CENABLE /* FUNC CALL */				ASM_LINE_SEP	\
+    ldo 64(%sp), %sp					ASM_LINE_SEP	\
+    ldo -64(%sp), %sp					ASM_LINE_SEP	\
+    LDW_PIC						ASM_LINE_SEP	\
+    /* restore syscall args */				ASM_LINE_SEP	\
+    POPARGS_##args					ASM_LINE_SEP	\
+    /* save r4 in arg0 stack slot */			ASM_LINE_SEP	\
+    stw %r4, -36(%sr0,%sp)				ASM_LINE_SEP	\
+    /* save mask from cenable */			ASM_LINE_SEP	\
+    copy %ret0, %r4					ASM_LINE_SEP	\
+    ble 0x100(%sr2,%r0)					ASM_LINE_SEP    \
+    ldi SYS_ify (syscall_name), %r20			ASM_LINE_SEP	\
+    LDW_PIC						ASM_LINE_SEP	\
+    /* pass mask as arg0 to cdisable */			ASM_LINE_SEP	\
+    copy %r4, %r26					ASM_LINE_SEP	\
+    copy %ret0, %r4					ASM_LINE_SEP	\
+    CDISABLE						ASM_LINE_SEP	\
+    ldo 64(%sp), %sp					ASM_LINE_SEP	\
+    ldo -64(%sp), %sp					ASM_LINE_SEP	\
+    LDW_PIC						ASM_LINE_SEP	\
+    /* compare error */					ASM_LINE_SEP	\
+    ldi NO_ERROR,%r1					ASM_LINE_SEP	\
+    /* branch if no error */				ASM_LINE_SEP	\
+    cmpb,>>=,n %r1,%r4,Lpre_end				ASM_LINE_SEP	\
+    nop							ASM_LINE_SEP	\
+    SYSCALL_ERROR_HANDLER				ASM_LINE_SEP	\
+    ldo 64(%sp), %sp					ASM_LINE_SEP	\
+    ldo -64(%sp), %sp					ASM_LINE_SEP	\
+    /* No need to LDW_PIC */				ASM_LINE_SEP	\
+    /* make syscall res value positive */		ASM_LINE_SEP	\
+    sub %r0, %r4, %r4					ASM_LINE_SEP	\
+    /* store into errno location */			ASM_LINE_SEP	\
+    stw %r4, 0(%sr0,%ret0)				ASM_LINE_SEP	\
+    /* return -1 */					ASM_LINE_SEP	\
+    ldo -1(%r0), %ret0					ASM_LINE_SEP	\
+  Lpre_end:						ASM_LINE_SEP	\
+    ldw -20(%sr0,%sp), %rp             			ASM_LINE_SEP	\
+    /* No need to LDW_PIC */				ASM_LINE_SEP	\
+    ldw -36(%sr0,%sp), %r4				ASM_LINE_SEP
+
+/* Save arguments into our frame */
+# define PUSHARGS_0	/* nothing to do */
+# define PUSHARGS_1	PUSHARGS_0 stw %r26, -36(%sr0,%sp)	ASM_LINE_SEP
+# define PUSHARGS_2	PUSHARGS_1 stw %r25, -40(%sr0,%sp)	ASM_LINE_SEP
+# define PUSHARGS_3	PUSHARGS_2 stw %r24, -44(%sr0,%sp)	ASM_LINE_SEP
+# define PUSHARGS_4	PUSHARGS_3 stw %r23, -48(%sr0,%sp)	ASM_LINE_SEP
+# define PUSHARGS_5	PUSHARGS_4 /* Args are on the stack... */
+# define PUSHARGS_6	PUSHARGS_5
+
+/* Bring them back from the stack */
+# define POPARGS_0	/* nothing to do */
+# define POPARGS_1	POPARGS_0 ldw -36(%sr0,%sp), %r26	ASM_LINE_SEP
+# define POPARGS_2	POPARGS_1 ldw -40(%sr0,%sp), %r25	ASM_LINE_SEP
+# define POPARGS_3	POPARGS_2 ldw -44(%sr0,%sp), %r24	ASM_LINE_SEP
+# define POPARGS_4	POPARGS_3 ldw -48(%sr0,%sp), %r23	ASM_LINE_SEP
+# define POPARGS_5	POPARGS_4 ldw -52(%sr0,%sp), %r22	ASM_LINE_SEP
+# define POPARGS_6	POPARGS_5 ldw -56(%sr0,%sp), %r21	ASM_LINE_SEP
+
+# ifdef IS_IN_libpthread
+#  ifdef PIC
+#   define CENABLE .import __pthread_enable_asynccancel,code ASM_LINE_SEP \
+			bl __pthread_enable_asynccancel,%r2 ASM_LINE_SEP
+#   define CDISABLE .import __pthread_disable_asynccancel,code ASM_LINE_SEP \
+			bl __pthread_disable_asynccancel,%r2 ASM_LINE_SEP 
+#  else
+#   define CENABLE .import __pthread_enable_asynccancel,code ASM_LINE_SEP \
+			bl __pthread_enable_asynccancel,%r2 ASM_LINE_SEP
+#   define CDISABLE .import __pthread_disable_asynccancel,code ASM_LINE_SEP \
+			bl __pthread_disable_asynccancel,%r2 ASM_LINE_SEP 
+#  endif
+# elif !defined NOT_IN_libc
+#  ifdef PIC
+#   define CENABLE .import __libc_enable_asynccancel,code ASM_LINE_SEP \
+			bl __libc_enable_asynccancel,%r2 ASM_LINE_SEP 
+#   define CDISABLE	.import __libc_disable_asynccancel,code ASM_LINE_SEP \
+			bl __libc_disable_asynccancel,%r2 ASM_LINE_SEP 
+#  else
+#   define CENABLE .import __libc_enable_asynccancel,code ASM_LINE_SEP \
+			bl __libc_enable_asynccancel,%r2 ASM_LINE_SEP 
+#   define CDISABLE	.import __libc_disable_asynccancel,code ASM_LINE_SEP \
+			bl __libc_disable_asynccancel,%r2 ASM_LINE_SEP 
+#  endif
+# else
+#  ifdef PIC
+#   define CENABLE .import __librt_enable_asynccancel,code ASM_LINE_SEP \
+			bl __librt_enable_asynccancel,%r2 ASM_LINE_SEP 
+#   define CDISABLE .import __librt_disable_asynccancel,code ASM_LINE_SEP \
+			bl __librt_disable_asynccancel,%r2 ASM_LINE_SEP 
+#  else
+#   define CENABLE .import __librt_enable_asynccancel,code ASM_LINE_SEP \
+			bl __librt_enable_asynccancel,%r2 ASM_LINE_SEP 
+#   define CDISABLE .import __librt_disable_asynccancel,code ASM_LINE_SEP \
+			bl __librt_disable_asynccancel,%r2 ASM_LINE_SEP 
+#  endif
+# endif	
+
+/* p_header.multiple_threads is +12 from the pthread_descr struct start,
+   We could have called __get_cr27() but we really want less overhead */
+# define MULTIPLE_THREADS_OFFSET 0xC
+
+/* cr27 has been initialized to 0x0 by kernel */
+# define NO_THREAD_CR27 0x0
+			
+# ifdef IS_IN_libpthread
+#  define __local_multiple_threads __pthread_multiple_threads
+# elif !defined NOT_IN_libc
+#  define __local_multiple_threads __libc_multiple_threads
+# else
+#  define __local_multiple_threads __librt_multiple_threads
+# endif
+
+# ifndef __ASSEMBLER__
+ extern int __local_multiple_threads attribute_hidden;
+#  define SINGLE_THREAD_P __builtin_expect (__local_multiple_threads == 0, 1)
+# else
+/* This ALT version requires newer kernel support */
+#  define SINGLE_THREAD_P_MFCTL						\
+	mfctl %cr27, %ret0					ASM_LINE_SEP	\
+	cmpib,= NO_THREAD_CR27,%ret0,Lstp			ASM_LINE_SEP	\
+	nop							ASM_LINE_SEP	\
+	ldw MULTIPLE_THREADS_OFFSET(%sr0,%ret0),%ret0		ASM_LINE_SEP	\
+ Lstp:								ASM_LINE_SEP	
+#  ifdef PIC
+/* Slower version uses GOT to get value of __local_multiple_threads */
+#   define SINGLE_THREAD_P							\
+	addil LT%__local_multiple_threads, %r19			ASM_LINE_SEP	\
+	ldw RT%__local_multiple_threads(%sr0,%r1), %ret0	ASM_LINE_SEP	\
+	ldw 0(%sr0,%ret0), %ret0 				ASM_LINE_SEP
+#  else
+  /* Slow non-pic version using DP */
+#   define SINGLE_THREAD_P								\
+	addil LR%__local_multiple_threads-$global$,%r27  		ASM_LINE_SEP	\
+	ldw RR%__local_multiple_threads-$global$(%sr0,%r1),%ret0	ASM_LINE_SEP
+#  endif	
+# endif
+#elif !defined __ASSEMBLER__
+
+/* This code should never be used but we define it anyhow.  */
+# define SINGLE_THREAD_P (1)
+
+#endif
+/* !defined NOT_IN_libc || defined IS_IN_libpthread */
+
+
--- glibc-2.3.2-orig-debian/localedata/gen-locale.sh	2003-10-22 01:03:54.000000000 -0400
+++ glibc-2.3.2/localedata/gen-locale.sh	2003-10-22 01:07:38.000000000 -0400
@@ -47,6 +47,7 @@
 locale=`echo $locfile|sed 's|\([^.]*\)[.].*/LC_CTYPE|\1|'`
 charmap=`echo $locfile|sed 's|[^.]*[.]\(.*\)/LC_CTYPE|\1|'`
 
+echo "Running \"$0 $common_objpfx $localedef $locfile\""
 echo "Generating locale $locale.$charmap: this might take a while..."
 generate_locale `echo $charmap | sed -e s/SJIS/SHIFT_JIS/` $locale \
 		$locale.$charmap
--- glibc-2.3.2-orig-debian/malloc/thread-m.h	2003-10-22 01:06:10.000000000 -0400
+++ glibc-2.3.2/malloc/thread-m.h	2003-10-22 01:07:38.000000000 -0400
@@ -59,6 +59,28 @@
 #define mutex_unlock(m)		\
   __libc_maybe_call2 (pthread_mutex_unlock, (m), (*(int *)(m) = 0))
 
+# if(defined __hppa__)
+/* Since our lock structure does not tolerate being initialized to zero, we must
+   modify the standard function calls made by malloc */
+#  undef mutex_init
+#  undef mutex_lock
+#  undef mutex_trylock
+#  undef mutex_unlock
+#  define mutex_init(m)		\
+	__libc_maybe_call (__pthread_mutex_init, (m, NULL), \
+			(((m)->__m_lock.__spinlock = __LT_SPINLOCK_INIT),(*(int *)(m))) )
+#  define mutex_lock(m)		\
+	__libc_maybe_call (__pthread_mutex_lock, (m), \
+			(__load_and_clear(&((m)->__m_lock.__spinlock)), 0))
+#  define mutex_trylock(m)	\
+	__libc_maybe_call (__pthread_mutex_trylock, (m), \
+			(*(int *)(m) ? 1 : (__load_and_clear(&((m)->__m_lock.__spinlock)), 0)))
+#  define mutex_unlock(m)	\
+	__libc_maybe_call (__pthread_mutex_unlock, (m), \
+			(((m)->__m_lock.__spinlock = __LT_SPINLOCK_INIT), (*(int *)(m))) )
+# endif 
+/* if(defined __hppa__) */
+	
 #else
 
 #define mutex_init(m)		\
--- glibc-2.3.2-orig-debian/sysdeps/generic/framestate.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/generic/framestate.c	2003-10-22 01:07:38.000000000 -0400
@@ -41,7 +41,11 @@
       if (handle == NULL
 	  || (frame_state_for
 	      = (framesf) __libc_dlsym (handle, "__frame_state_for")) == NULL)
+#ifndef __USING_SJLJ_EXCEPTIONS__
 	frame_state_for = fallback_frame_state_for;
+#else
+      	frame_state_for = abort;
+#endif
     }
 
   return frame_state_for (pc, frame_state);
--- glibc-2.3.2-orig-debian/sysdeps/generic/unwind-dw2.c	2003-10-22 01:06:11.000000000 -0400
+++ glibc-2.3.2/sysdeps/generic/unwind-dw2.c	2003-10-22 01:08:07.000000000 -0400
@@ -39,7 +39,6 @@
 #endif
 
 
-#ifndef __USING_SJLJ_EXCEPTIONS__
 
 #ifndef STACK_GROWS_DOWNWARD
 #define STACK_GROWS_DOWNWARD 0
@@ -1287,4 +1286,3 @@
 #include "unwind.inc"
 
 #endif /* _LIBC */
-#endif /* !USING_SJLJ_EXCEPTIONS */
--- glibc-2.3.2-orig-debian/sysdeps/hppa/Dist	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/Dist	2003-10-22 01:07:38.000000000 -0400
@@ -1,2 +1,3 @@
+libgcc-compat.c
 dl-symaddr.c
 dl-fptr.c
--- glibc-2.3.2-orig-debian/sysdeps/hppa/Makefile	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/Makefile	2003-10-22 01:07:38.000000000 -0400
@@ -22,12 +22,19 @@
 # CFLAGS-.os += -ffunction-sections
 LDFLAGS-c_pic.os += -Wl,--unique=.text*
 
-ifeq ($(subdir),malloc)
-CFLAGS-malloc.c += -DMALLOC_ALIGNMENT=16
-endif
-
 ifeq ($(subdir),elf)
 CFLAGS-rtld.c += -mdisable-fpregs
 dl-routines += dl-symaddr dl-fptr
 rtld-routines += dl-symaddr dl-fptr
 endif
+
+ifeq ($(subdir),csu)
+ifeq (yes,$(build-shared))
+# Compatibility
+ifeq (yes,$(have-protected))
+CPPFLAGS-libgcc-compat.c = -DHAVE_DOT_HIDDEN
+endif
+sysdep_routines += libgcc-compat
+shared-only-routines += libgcc-compat
+endif
+endif
--- glibc-2.3.2-orig-debian/sysdeps/hppa/Versions	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/Versions	2003-10-22 01:07:38.000000000 -0400
@@ -5,3 +5,8 @@
     _dl_function_address;
   }
 }
+libc {
+  GLIBC_2.2 {
+    __clz_tab;
+  }
+}
--- glibc-2.3.2-orig-debian/sysdeps/hppa/atomicity.h	1969-12-31 19:00:00.000000000 -0500
+++ glibc-2.3.2/sysdeps/hppa/atomicity.h	2003-10-22 01:07:38.000000000 -0400
@@ -0,0 +1,55 @@
+/* Low-level functions for atomic operations.  HP-PARISC version.
+   Copyright (C) 1997,2001 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   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., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _ATOMICITY_H
+#define _ATOMICITY_H	1
+
+#include <inttypes.h>
+
+#warning stub atomicity functions are not atomic
+#warning CAO This will get implemented soon
+
+static inline int
+__attribute__ ((unused))
+exchange_and_add (volatile uint32_t *mem, int val)
+{
+  int result = *mem;
+  *mem += val;
+  return result;
+}
+
+static inline void
+__attribute__ ((unused))
+atomic_add (volatile uint32_t *mem, int val)
+{
+  *mem += val;
+}
+
+static inline int
+__attribute__ ((unused))
+compare_and_swap (volatile long int *p, long int oldval, long int newval)
+{
+  if (*p != oldval)
+    return 0;
+
+  *p = newval;
+  return 1;
+}
+
+#endif /* atomicity.h */
--- glibc-2.3.2-orig-debian/sysdeps/hppa/dl-fptr.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/dl-fptr.c	2003-10-22 01:07:38.000000000 -0400
@@ -30,7 +30,7 @@
 # include <pt-machine.h>
 
 /* Remember, we use 0 to mean that a lock is taken on PA-RISC. */
-static int __hppa_fptr_lock = 1;
+static __atomic_lock_t __hppa_fptr_lock = __LT_SPINLOCK_ALT_INIT;
 #endif
 
 /* Because ld.so is now versioned, these functions can be in their own
@@ -127,7 +127,7 @@
 #ifdef _LIBC_REENTRANT
   /* Release the lock.  Again, remember, zero means the lock is taken!  */
   if (mem == NULL)
-    __hppa_fptr_lock = 1;
+    __hppa_fptr_lock = __LT_SPINLOCK_INIT;
 #endif
 
   /* Set bit 30 to indicate to $$dyncall that this is a PLABEL. */
@@ -180,7 +180,7 @@
 
 #ifdef _LIBC_REENTRANT
   /* Release the lock. */
-  __hppa_fptr_lock = 1;
+  __hppa_fptr_lock = __LT_SPINLOCK_INIT;
 #endif
 }
 
@@ -190,6 +190,8 @@
   Elf32_Addr addr = (Elf32_Addr) address;
   struct hppa_fptr *f;
 
+  address = (void *)((unsigned long)address &~ 3); /* Clear the bottom two bits.  See make_fptr. */
+  
 #ifdef _LIBC_REENTRANT
   /* Make sure we are alone.  */
   while (testandset (&__hppa_fptr_lock));
@@ -204,7 +206,7 @@
 
 #ifdef _LIBC_REENTRANT
   /* Release the lock.   */
-  __hppa_fptr_lock = 1;
+  __hppa_fptr_lock = __LT_SPINLOCK_INIT;
 #endif
 
   return addr;
--- glibc-2.3.2-orig-debian/sysdeps/hppa/dl-machine.h	2003-10-22 01:06:11.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/dl-machine.h	2003-10-22 01:10:26.000000000 -0400
@@ -1,5 +1,5 @@
 /* Machine-dependent ELF dynamic relocation inline functions.  PA-RISC version.
-   Copyright (C) 1995-1997,1999,2000,2001,2002, 2003
+   Copyright (C) 1995-1997,1999-2003
 	Free Software Foundation, Inc.
    Contributed by David Huggins-Daines <dhd@debian.org>
    This file is part of the GNU C Library.
@@ -29,8 +29,15 @@
 #include <link.h>
 #include <assert.h>
 
+# define VALID_ELF_OSABI(osabi)		((osabi == ELFOSABI_SYSV) || (osabi == ELFOSABI_LINUX))
+# define VALID_ELF_ABIVERSION(ver)	(ver == 0)
+# define VALID_ELF_HEADER(hdr,exp,size) \
+  memcmp (hdr,exp,size-2) == 0 \
+  && VALID_ELF_OSABI (hdr[EI_OSABI]) \
+  && VALID_ELF_ABIVERSION (hdr[EI_ABIVERSION])
+
 /* These must match the definition of the stub in bfd/elf32-hppa.c. */
-#define SIZEOF_PLT_STUB (4*4)
+#define SIZEOF_PLT_STUB (7*4)
 #define GOT_FROM_PLT_STUB (4*4)
 
 /* A PLABEL is a function descriptor.  Properly they consist of just
@@ -67,45 +74,41 @@
   return ehdr->e_machine == EM_PARISC;
 }
 
-
 /* Return the link-time address of _DYNAMIC.  */
 static inline Elf32_Addr
+elf_machine_dynamic (void) __attribute__ ((const));
+
+static inline Elf32_Addr
 elf_machine_dynamic (void)
 {
   Elf32_Addr dynamic;
 
-#if 0
-  /* Use this method if GOT address not yet set up.  */
-  asm (
-"	b,l	1f,%0\n"
+  asm ("b,l	1f,%0\n"
 "	depi	0,31,2,%0\n"
 "1:	addil	L'_GLOBAL_OFFSET_TABLE_ - ($PIC_pcrel$0 - 8),%0\n"
 "	ldw	R'_GLOBAL_OFFSET_TABLE_ - ($PIC_pcrel$0 - 12)(%%r1),%0\n"
-      : "=r" (dynamic) : : "r1");
-#else
-  /* This works because we already have our GOT address available.  */
-  dynamic = (Elf32_Addr) &_DYNAMIC;
-#endif
+       : "=r" (dynamic) : : "r1");
 
   return dynamic;
 }
 
 /* Return the run-time load address of the shared object.  */
 static inline Elf32_Addr
+elf_machine_load_address (void) __attribute__ ((const));
+
+static inline Elf32_Addr
 elf_machine_load_address (void)
 {
-  Elf32_Addr dynamic, dynamic_linkaddress;
+  Elf32_Addr dynamic;
 
   asm (
 "	b,l	1f,%0\n"
 "	depi	0,31,2,%0\n"
 "1:	addil	L'_DYNAMIC - ($PIC_pcrel$0 - 8),%0\n"
-"	ldo	R'_DYNAMIC - ($PIC_pcrel$0 - 12)(%%r1),%1\n"
-"	addil	L'_GLOBAL_OFFSET_TABLE_ - ($PIC_pcrel$0 - 16),%0\n"
-"	ldw	R'_GLOBAL_OFFSET_TABLE_ - ($PIC_pcrel$0 - 20)(%%r1),%0\n"
-   : "=r" (dynamic_linkaddress), "=r" (dynamic) : : "r1");
+"	ldo	R'_DYNAMIC - ($PIC_pcrel$0 - 12)(%%r1),%0\n"
+   : "=r" (dynamic) : : "r1");
 
-  return dynamic - dynamic_linkaddress;
+  return dynamic - elf_machine_dynamic ();
 }
 
 /* Fixup a PLT entry to bounce directly to the function at VALUE.  */
@@ -168,41 +171,39 @@
 	      fptr = (struct hppa_fptr *) (reloc->r_offset + l_addr);
 	      if (r_sym != 0)
 		{
-		  /* Relocate the pointer to the stub.  */
-		  fptr->func += l_addr;
-		  /* Instead of the LTP value, we put the reloc offset
-		     here.  The trampoline code will load the proper
-		     LTP and pass the reloc offset to the fixup
-		     function.  */
-		  fptr->gp = iplt - jmprel;
 		  if (!got)
 		    {
 		      static union {
 			unsigned char c[8];
 			Elf32_Addr i[2];
 		      } sig = {{0x00,0xc0,0xff,0xee, 0xde,0xad,0xbe,0xef}};
+		      const Elf32_Rela *last_rel;
+
+		      last_rel = (const Elf32_Rela *) end_jmprel - 1;
+
+		      /* The stub is immediately after the last .plt
+			 entry.  Rely on .plt relocs being ordered.  */
+		      if (last_rel->r_offset == 0)
+			return 0;
 
 		      /* Find our .got section.  It's right after the
 			 stub.  */
-		      got = (Elf32_Addr *) (fptr->func + GOT_FROM_PLT_STUB);
+		      got = (Elf32_Addr *) (last_rel->r_offset + l_addr
+					    + 8 + SIZEOF_PLT_STUB);
 
-		      /* Sanity check to see if the address we are
-                         going to check below is within a reasonable
-                         approximation of the bounds of the PLT (or,
-                         at least, is at an address that won't fault
-                         on read).  Then check for the magic signature
-                         above. */
-		      if (fptr->func < (Elf32_Addr) fptr + sizeof(*fptr))
-			  return 0;
-		      if (fptr->func >
-			  ((Elf32_Addr) fptr
-			   + SIZEOF_PLT_STUB
-			   + ((l->l_info[DT_PLTRELSZ]->d_un.d_val / sizeof (Elf32_Rela))
-			      * 8)))
-			return 0;
+		      /* Check the magic signature.  */
 		      if (got[-2] != sig.i[0] || got[-1] != sig.i[1])
 			return 0; /* No lazy linking for you! */
 		    }
+
+		  /* Relocate the pointer to the stub.  */
+		  fptr->func = (Elf32_Addr) got - GOT_FROM_PLT_STUB;
+
+		  /* Instead of the LTP value, we put the reloc offset
+		     here.  The trampoline code will load the proper
+		     LTP and pass the reloc offset to the fixup
+		     function.  */
+		  fptr->gp = iplt - jmprel;
 		}
 	      else
 		{
@@ -272,22 +273,24 @@
 "	stw	%r25,-40(%sp)\n" /* argc */				\
 "	stw	%r24,-44(%sp)\n" /* argv */				\
 									\
-	/* We need the LTP, and we need it now. */			\
-	/* $PIC_pcrel$0 points 8 bytes past the current instruction,	\
-	   just like a branch reloc.  This sequence gets us the runtime	\
-	   address of _DYNAMIC. */					\
+	/* We need the LTP, and we need it now.				\
+	   $PIC_pcrel$0 points 8 bytes past the current instruction,	\
+	   just like a branch reloc.  This sequence gets us the		\
+	   runtime address of _DYNAMIC. */				\
 "	bl	0f,%r19\n"						\
 "	depi	0,31,2,%r19\n"	/* clear priviledge bits */		\
 "0:	addil	L'_DYNAMIC - ($PIC_pcrel$0 - 8),%r19\n"			\
 "	ldo	R'_DYNAMIC - ($PIC_pcrel$0 - 12)(%r1),%r26\n"		\
 									\
-	/* Also get the link time address from the first entry of the GOT.  */ \
+	/* The link time address is stored in the first entry of the	\
+	   GOT.  */							\
 "	addil	L'_GLOBAL_OFFSET_TABLE_ - ($PIC_pcrel$0 - 16),%r19\n"	\
 "	ldw	R'_GLOBAL_OFFSET_TABLE_ - ($PIC_pcrel$0 - 20)(%r1),%r20\n" \
 									\
 "	sub	%r26,%r20,%r20\n"	/* Calculate load offset */	\
 									\
-	/* Rummage through the dynamic entries, looking for DT_PLTGOT.  */ \
+	/* Rummage through the dynamic entries, looking for		\
+	   DT_PLTGOT.  */						\
 "	ldw,ma	8(%r26),%r19\n"						\
 "1:	cmpib,=,n 3,%r19,2f\n"	/* tag == DT_PLTGOT? */			\
 "	cmpib,<>,n 0,%r19,1b\n"						\
@@ -307,8 +310,8 @@
 	   |         32 bytes of magic       |				\
 	   |---------------------------------|				\
 	   | 32 bytes argument/sp save area  |				\
-	   |---------------------------------|  ((current->mm->env_end) + 63 & ~63) \
-	   |         N bytes of slack        |				\
+	   |---------------------------------|  ((current->mm->env_end)	\
+	   |         N bytes of slack        |	 + 63 & ~63)		\
 	   |---------------------------------|				\
 	   |      envvar and arg strings     |				\
 	   |---------------------------------|				\
@@ -376,7 +379,7 @@
 "	bl	_dl_init_internal,%r2\n"				\
 "	ldo	4(%r23),%r23\n"	/* delay slot */			\
 									\
-	/* Reload argc, argv  to the registers start.S expects them in (feh) */ \
+	/* Reload argc, argv to the registers start.S expects.  */	\
 "	ldw	-40(%sp),%r25\n"					\
 "	ldw	-44(%sp),%r24\n"					\
 									\
@@ -388,8 +391,8 @@
 "	.word	0xdeadbeef\n"						\
 "	.previous\n"							\
 									\
-	/* %r3 contains a function pointer, we need to mask out the lower \
-	 * bits and load the gp and jump address. */			\
+	/* %r3 contains a function pointer, we need to mask out the	\
+	   lower bits and load the gp and jump address. */		\
 "	depi	0,31,2,%r3\n"						\
 "	ldw	0(%r3),%r2\n"						\
 "	addil	LT'__dl_fini_plabel,%r19\n"				\
@@ -407,43 +410,41 @@
    Enter with r19 = reloc offset, r20 = got-8, r21 = fixup ltp.  */
 #define TRAMPOLINE_TEMPLATE(tramp_name, fixup_name) \
   extern void tramp_name (void);		    \
-  asm ( "\
-	/* Trampoline for " #tramp_name " */				    \n\
-	.globl " #tramp_name "						    \n\
-	.type " #tramp_name ",@function					    \n\
-" #tramp_name ":							    \n\
-	/* Save return pointer */					    \n\
-	stw	%r2,-20(%sp)						    \n\
-	/* Save argument registers in the call stack frame. */		    \n\
-	stw	%r26,-36(%sp)						    \n\
-	stw	%r25,-40(%sp)						    \n\
-	stw	%r24,-44(%sp)						    \n\
-	stw	%r23,-48(%sp)						    \n\
-	/* Build a call frame. */					    \n\
-	stwm	%sp,64(%sp)						    \n\
-									    \n\
-	/* Set up args to fixup func.  */				    \n\
-	ldw	8+4(%r20),%r26	/* got[1] == struct link_map *  */	    \n\
-	copy	%r19,%r25	/* reloc offset  */			    \n\
-									    \n\
-	/* Call the real address resolver. */				    \n\
-	bl	" #fixup_name ",%r2					    \n\
-	copy	%r21,%r19	/* delay slot, set fixup func ltp */	    \n\
-									    \n\
-	ldwm	-64(%sp),%sp						    \n\
-	/* Arguments. */						    \n\
-	ldw	-36(%sp),%r26						    \n\
-	ldw	-40(%sp),%r25						    \n\
-	ldw	-44(%sp),%r24						    \n\
-	ldw	-48(%sp),%r23						    \n\
-	/* Return pointer. */						    \n\
-	ldw	-20(%sp),%r2						    \n\
-	/* Call the real function. */					    \n\
-	ldw	0(%r28),%r22						    \n\
-	bv	%r0(%r22)						    \n\
-	ldw	4(%r28),%r19						    \n\
-");
-
+  asm (".globl " #tramp_name "\n"					\
+ "	.type " #tramp_name ",@function\n"				\
+  #tramp_name ":\n"							\
+ 	/* Save return pointer */					\
+ "	stw	%r2,-20(%sp)\n"						\
+ 	/* Save argument registers in the call stack frame. */		\
+ "	stw	%r26,-36(%sp)\n"					\
+ "	stw	%r25,-40(%sp)\n"					\
+ "	stw	%r24,-44(%sp)\n"					\
+ "	stw	%r23,-48(%sp)\n"					\
+ 	/* Build a call frame, and save structure pointer. */		\
+ "	stwm	%r28,64(%sp)\n"						\
+ 									\
+ 	/* Set up args to fixup func.  */				\
+ "	ldw	8+4(%r20),%r26\n" /* got[1] == struct link_map *  */	\
+ "	copy	%r19,%r25\n"	  /* reloc offset  */			\
+ 									\
+ 	/* Call the real address resolver. */				\
+ "	bl	" #fixup_name ",%r2\n"					\
+ "	copy	%r21,%r19\n"	  /* delay slot, set fixup func ltp */	\
+ 									\
+ "	ldw	0(%r28),%r22\n"	  /* load up the returned func ptr */	\
+ "	ldw	4(%r28),%r19\n"						\
+ "	ldwm	-64(%sp),%r28\n"					\
+ 	/* Arguments. */						\
+ "	ldw	-36(%sp),%r26\n"					\
+ "	ldw	-40(%sp),%r25\n"					\
+ "	ldw	-44(%sp),%r24\n"					\
+ "	ldw	-48(%sp),%r23\n"					\
+ 	/* Call the real function. */					\
+ "	bv	%r0(%r22)\n"						\
+ 	/* Return pointer. */						\
+ "	ldw	-20(%sp),%r2\n"						\
+        );
+  
 #ifndef PROF
 #define ELF_MACHINE_RUNTIME_TRAMPOLINE			\
   TRAMPOLINE_TEMPLATE (_dl_runtime_resolve, fixup);	\
@@ -470,16 +471,32 @@
 /* We only use RELA. */
 #define ELF_MACHINE_NO_REL 1
 
+/* Tell dynamic-link that PA needs the extra link_map structure */
+#define ELF_MACHINE_REL_RELATIVE_NEEDSLINKMAP 1
+#define ELF_MACHINE_RELA_RELATIVE_NEEDSLINKMAP 1
+	
 /* Return the address of the entry point. */
 #define ELF_MACHINE_START_ADDRESS(map, start) \
   DL_FUNCTION_ADDRESS (map, start)
 
+/* We define an initialization functions.  This is called very early in
+ *    _dl_sysdep_start.  */
+#define DL_PLATFORM_INIT dl_platform_init ()
+
+static inline void __attribute__ ((unused))
+dl_platform_init (void)
+{
+	if (GL(dl_platform) != NULL && *GL(dl_platform) == '\0')
+	/* Avoid an empty string which would disturb us.  */
+		GL(dl_platform) = NULL;
+}
+	
 #endif /* !dl_machine_h */
 
 /* These are only actually used where RESOLVE_MAP is defined, anyway. */
 #ifdef RESOLVE_MAP
 
-static inline void
+auto void __attribute__((always_inline))
 elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
 		  const Elf32_Sym *sym, const struct r_found_version *version,
 		  void *const reloc_addr_arg)
@@ -569,15 +586,15 @@
 	   probably haven't relocated the necessary values by this
 	   point so we have to find them ourselves. */
 
-	asm ("bl	0f,%0						    \n\
-	      depi	0,31,2,%0					    \n\
-0:	      addil	L'__boot_ldso_fptr - ($PIC_pcrel$0 - 8),%0	    \n\
-	      ldo	R'__boot_ldso_fptr - ($PIC_pcrel$0 - 12)(%%r1),%1   \n\
-	      addil	L'__fptr_root - ($PIC_pcrel$0 - 16),%0		    \n\
-	      ldo	R'__fptr_root - ($PIC_pcrel$0 - 20)(%%r1),%2	    \n\
-	      addil	L'__fptr_count - ($PIC_pcrel$0 - 24),%0		    \n\
-	      ldo	R'__fptr_count - ($PIC_pcrel$0 - 28)(%%r1),%3"
-	     :
+ 	asm ("bl	0f,%0\n\t"
+ 	     "depi	0,31,2,%0\n\t"
+ 	     "0:\taddil	L'__boot_ldso_fptr - ($PIC_pcrel$0 - 8),%0\n\t"
+ 	     "ldo	R'__boot_ldso_fptr - ($PIC_pcrel$0 - 12)(%%r1),%1\n\t"
+ 	     "addil	L'__fptr_root - ($PIC_pcrel$0 - 16),%0\n\t"
+ 	     "ldo	R'__fptr_root - ($PIC_pcrel$0 - 20)(%%r1),%2\n\t"
+ 	     "addil	L'__fptr_count - ($PIC_pcrel$0 - 24),%0\n\t"
+ 	     "ldo	R'__fptr_count - ($PIC_pcrel$0 - 28)(%%r1),%3"
+  	     :
 	     "=r" (dot),
 	     "=r" (p_boot_ldso_fptr),
 	     "=r" (p_fptr_root),
@@ -636,7 +653,7 @@
 
 /* hppa doesn't have an R_PARISC_RELATIVE reloc, but uses relocs with
    ELF32_R_SYM (info) == 0 for a similar purpose.  */
-static inline void
+auto void __attribute__((always_inline))
 elf_machine_rela_relative (struct link_map *map, Elf32_Addr l_addr,
 			   const Elf32_Rela *reloc,
 			   void *const reloc_addr_arg)
@@ -682,7 +699,7 @@
   *reloc_addr = value;
 }
 
-static inline void
+auto void __attribute__((always_inline))
 elf_machine_lazy_rel (struct link_map *map,
 		      Elf32_Addr l_addr, const Elf32_Rela *reloc)
 {
--- glibc-2.3.2-orig-debian/sysdeps/hppa/elf/entry.h	1969-12-31 19:00:00.000000000 -0500
+++ glibc-2.3.2/sysdeps/hppa/elf/entry.h	2003-10-22 01:07:38.000000000 -0400
@@ -0,0 +1,10 @@
+#ifndef __ASSEMBLY__
+extern void _start (void);
+#endif
+
+/* The function's entry point is stored in the first word of the
+   function descriptor (plabel) of _start().  */
+#define ENTRY_POINT ({long int *tmp = (long int *)((long)_start & ~2); tmp[0];})
+
+/* We have to provide a special declaration.  */
+#define ENTRY_POINT_DECL(class) class void _start (void);
--- glibc-2.3.2-orig-debian/sysdeps/hppa/fpu/fclrexcpt.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/fpu/fclrexcpt.c	2003-10-22 01:07:38.000000000 -0400
@@ -29,7 +29,7 @@
   __asm__ ("fstd %%fr0,0(%1)" : "=m" (*sw) : "r" (sw));
 
   /* Clear all the relevant bits. */
-  sw[0] &= ~(excepts & FE_ALL_EXCEPT) << 27;
+  sw[0] &= ~((excepts & FE_ALL_EXCEPT) << 27);
   __asm__ ("fldd 0(%0),%%fr0" : : "r" (sw));
 
   /* Success.  */
--- glibc-2.3.2-orig-debian/sysdeps/hppa/fpu/fegetenv.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/fpu/fegetenv.c	2003-10-22 01:07:38.000000000 -0400
@@ -23,11 +23,12 @@
 int
 fegetenv (fenv_t *envp)
 {
-  __asm__ (
-	   "fstd %%fr0,0(%2)\n"
-	   "fstd,ma %%fr1,8(%2)\n"
-	   "fstd,ma %%fr2,8(%2)\n"
-	   "fstd %%fr3,0(%2)\n"
-	   : "=m" (*envp), "=r" (envp) : "1" (envp));
+  fenv_t *temp = envp;
+  __asm__ ( "fstd,ma %%fr0,8(%1)\n"
+	    "fstd,ma %%fr1,8(%1)\n"
+	    "fstd,ma %%fr2,8(%1)\n"
+	    "fstd %%fr3,0(%1)\n"
+	    : "=m" (*temp), "+r" (temp)
+	  );  
   return 0;
 }
--- glibc-2.3.2-orig-debian/sysdeps/hppa/fpu/feholdexcpt.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/fpu/feholdexcpt.c	2003-10-22 01:07:38.000000000 -0400
@@ -25,36 +25,29 @@
 feholdexcept (fenv_t *envp)
 {
   fenv_t clear;
+  fenv_t * _regs = envp;
 
   /* Store the environment.  */
-  {
-    fenv_t * _regs = envp;
-    __asm__ (
-	     "fstd %%fr0,0(%2)\n"
-	     "fstd,ma %%fr1,8(%2)\n"
-	     "fstd,ma %%fr2,8(%2)\n"
-	     "fstd %%fr3,0(%2)\n"
-	     : "=m" (*_regs), "=r" (_regs) : "1" (_regs));
-    memcpy (&clear, envp, sizeof (clear));
-  }
+  __asm__ ( "fstd,ma %%fr0,8(%1)\n"
+	    "fstd,ma %%fr1,8(%1)\n"
+	    "fstd,ma %%fr2,8(%1)\n"
+	    "fstd %%fr3,0(%1)\n"
+	    : "=m" (*_regs), "+r" (_regs)
+	  );
+  
+  memcpy (&clear, envp, sizeof (clear));
 
-  /* Now clear all exceptions.  */
-  clear.__status_word &= ~(FE_ALL_EXCEPT << 27);
+  /* Now clear all exceptions (Enable bits and flags)  */
+  clear.__status_word &= ~((FE_ALL_EXCEPT << 27) | FE_ALL_EXCEPT);
   memset (clear.__exception, 0, sizeof (clear.__exception));
 
-  /* And set all exceptions to non-stop.  */
-  clear.__status_word &= ~FE_ALL_EXCEPT;
-
   /* Load the new environment. */
-  {
-    fenv_t * _regs = &clear + 1;
-    __asm__ (
-	     "fldd,mb -8(%2),%%fr3\n"
-	     "fldd,mb -8(%2),%%fr2\n"
-	     "fldd,mb -8(%2),%%fr1\n"
-	     "fldd -8(%2),%%fr0\n"
-	     : "=m" (*_regs), "=r" (_regs) : "1" (_regs));
-  }
+  __asm__ ( "fldd,ma -8(%1),%%fr3\n"
+	    "fldd,ma -8(%1),%%fr2\n"
+	    "fldd,ma -8(%1),%%fr1\n"
+	    "fldd 0(%1),%%fr0\n"
+	    : "=m" (*_regs), "+r" (_regs)
+	  );
 
   return 0;
 }
--- glibc-2.3.2-orig-debian/sysdeps/hppa/fpu/fesetenv.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/fpu/fesetenv.c	2003-10-22 01:07:38.000000000 -0400
@@ -26,24 +26,23 @@
 fesetenv (const fenv_t *envp)
 {
   fenv_t temp;
+  fenv_t * _regs = &temp;
 
   /* Install the environment specified by ENVP.  But there are a few
      values which we do not want to come from the saved environment.
      Therefore, we get the current environment and replace the values
      we want to use from the environment specified by the parameter.  */
-  {
-    fenv_t * _regs = &temp;
-    __asm__ (
-	     "fstd %%fr0,0(%2)\n"
-	     "fstd,ma %%fr1,8(%2)\n"
-	     "fstd,ma %%fr2,8(%2)\n"
-	     "fstd %%fr3,0(%2)\n"
-	     : "=m" (*_regs), "=r" (_regs) : "1" (_regs));
-  }
 
-  temp.__status_word &= ~(FE_ALL_EXCEPT
-			  | (FE_ALL_EXCEPT << 27)
-			  | FE_DOWNWARD);
+  __asm__ ( "fstd,ma %%fr0,8(%1)\n"
+	    "fstd,ma %%fr1,8(%1)\n"
+	    "fstd,ma %%fr2,8(%1)\n"
+	    "fstd %%fr3,0(%1)\n"
+	    : "=m" (*_regs), "+r" (_regs) 
+	  );
+
+  temp.__status_word &= ~((FE_ALL_EXCEPT << 27)
+			  | FE_DOWNWARD 
+			  | FE_ALL_EXCEPT);  
   if (envp == FE_DFL_ENV)
     ;
   else if (envp == FE_NOMASK_ENV)
@@ -55,16 +54,13 @@
 			      | (FE_ALL_EXCEPT << 27)));
 
   /* Load the new environment. */
-  {
-    fenv_t * _regs = &temp + 1;
-    __asm__ (
-	     "fldd,mb -8(%2),%%fr3\n"
-	     "fldd,mb -8(%2),%%fr2\n"
-	     "fldd,mb -8(%2),%%fr1\n"
-	     "fldd -8(%2),%%fr0\n"
-	     : "=m" (*_regs), "=r" (_regs) : "1" (_regs));
-  }
-
+  __asm__ ( "fldd,ma -8(%1),%%fr3\n"
+	    "fldd,ma -8(%1),%%fr2\n"
+	    "fldd,ma -8(%1),%%fr1\n"
+	    "fldd 0(%2),%%fr0\n"
+	    : "=m" (*_regs), "+r" (_regs)
+	  );
+  
   /* Success.  */
   return 0;
 }
--- glibc-2.3.2-orig-debian/sysdeps/hppa/fpu/feupdateenv.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/fpu/feupdateenv.c	2003-10-22 01:07:38.000000000 -0400
@@ -27,14 +27,12 @@
 
   /* Get the current exception status. */
   __asm__ ("fstd %%fr0,0(%1)" : "=m" (*sw) : "r" (sw));
-  sw[0] &= (FE_ALL_EXCEPT << 27);
-
+  sw[0] &= FE_ALL_EXCEPT;
+  envp->__status_word = envp->__status_word | sw[0];
+  
   /* Install new environment.  */
   fesetenv (envp);
 
-  /* Raise the saved exception. */
-  feraiseexcept (sw[0] >> 27);
-
   /* Success.  */
   return 0;
 }
--- glibc-2.3.2-orig-debian/sysdeps/hppa/fpu/fraiseexcpt.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/fpu/fraiseexcpt.c	2003-10-22 01:07:38.000000000 -0400
@@ -22,6 +22,9 @@
 #include <float.h>
 #include <math.h>
 
+/* Please see section 10, 
+   page 10-5 "Delayed Trapping" in the PA-RISC 2.0 Architecture manual */
+
 int
 feraiseexcept (int excepts)
 {
@@ -33,56 +36,64 @@
 
   /* We do these bits in assembly to be certain GCC doesn't optimize
      away something important, and so we can force delayed traps to
-     occur.  */
-
-  /* FIXME: These all need verification! */
+     occur. */
 
-  /* First: invalid exception.  */
+  /* We use "fldd 0(%%sr0,%%sp),%0" to flush the delayed exception */
+	
+  /* First: Invalid exception.  */
   if (excepts & FE_INVALID)
     {
       /* One example of a invalid operation is 0 * Infinity.  */
       double d = HUGE_VAL;
-      __asm__ __volatile__ ("fmpy,dbl %1,%%fr0,%0\n\t"
-			    /* FIXME: is this a proper trap barrier? */
-			    "fcpy,dbl %%fr0,%%fr0" : "=f" (d) : "0" (d));
+      __asm__ __volatile__ (
+		"	fcpy,dbl %%fr0,%%fr22\n"
+		"	fmpy,dbl %0,%%fr22,%0\n"
+		"	fldd 0(%%sr0,%%sp),%0"
+		: "+f" (d) : : "%fr22" );
     }
 
-  /* Next: division by zero.  */
+  /* Second: Division by zero.  */
   if (excepts & FE_DIVBYZERO)
     {
       double d = 1.0;
-      __asm__ __volatile__ ("fdiv,dbl %1,%%fr0,%0\n\t"
-			    "fcpy,dbl %%fr0,%%fr0" : "=f" (d) : "0" (d));
+      __asm__ __volatile__ (
+		"	fcpy,dbl %%fr0,%%fr22\n"
+		"	fdiv,dbl %0,%%fr22,%0\n"
+		"	fldd 0(%%sr0,%%sp),%0"
+		: "+f" (d) : : "%fr22" );
     }
 
-  /* Next: overflow.  */
-  /* FIXME: Compare with IA-64 - do we have the same problem? */
+  /* Third: Overflow.  */
   if (excepts & FE_OVERFLOW)
     {
       double d = DBL_MAX;
-
-      __asm__ __volatile__ ("fmpy,dbl %1,%1,%0\n\t"
-			    "fcpy,dbl %%fr0,%%fr0" : "=f" (d) : "0" (d));
+      __asm__ __volatile__ (
+		"	fadd,dbl %0,%0,%0\n"
+		"	fldd 0(%%sr0,%%sp),%0"
+		: "+f" (d) );
     }
 
-  /* Next: underflow.  */
+  /* Fourth: Underflow.  */
   if (excepts & FE_UNDERFLOW)
     {
       double d = DBL_MIN;
-      double e = 69.69;
-
-      __asm__ __volatile__ ("fdiv,dbl %1,%2,%0\n\t"
-			    "fcpy,dbl %%fr0,%%fr0" : "=f" (d) : "0" (d), "f" (e));
+      double e = 3.0;
+      __asm__ __volatile__ (
+		"	fdiv,dbl %0,%1,%0\n"
+		"	fldd 0(%%sr0,%%sp),%0"
+		: "+f" (d) : "f" (e) );
     }
 
-  /* Last: inexact.  */
+  /* Fifth: Inexact */
   if (excepts & FE_INEXACT)
     {
-      double d = 1.0;
-      double e = M_PI;
-
-      __asm__ __volatile__ ("fdiv,dbl %1,%2,%0\n\t"
-			    "fcpy,dbl %%fr0,%%fr0" : "=f" (d) : "0" (d), "f" (e));
+      double d = M_PI;
+      double e = 69.69;
+      __asm__ __volatile__ (
+		"	fdiv,dbl %0,%1,%%fr22\n"
+		"	fcnvfxt,dbl,sgl %%fr22,%%fr22L\n"
+		"	fldd 0(%%sr0,%%sp),%%fr22"
+		: : "f" (d), "f" (e) : "%fr22" );
     }
 
   /* Success.  */
--- glibc-2.3.2-orig-debian/sysdeps/hppa/fpu/fsetexcptflg.c	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/fpu/fsetexcptflg.c	2003-10-22 01:07:38.000000000 -0400
@@ -29,8 +29,7 @@
   /* Get the current status word. */
   __asm__ ("fstd %%fr0,0(%1)" : "=m" (*sw) : "r" (sw));
 
-  /* Install the new exception flags bits.  */
-  sw[0] &= ~(excepts & (FE_ALL_EXCEPT >> 27));
+  /* Clear exception flags, and install new neable trap bits  */
   sw[0] |= (*flagp & excepts & FE_ALL_EXCEPT) << 27;
 
   /* Store the new status word.  */
--- glibc-2.3.2-orig-debian/sysdeps/hppa/libgcc-compat.c	1969-12-31 19:00:00.000000000 -0500
+++ glibc-2.3.2/sysdeps/hppa/libgcc-compat.c	2003-10-22 01:07:38.000000000 -0400
@@ -0,0 +1,43 @@
+/* pre-.hidden libgcc compatibility
+   Copyright (C) 2002 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Randolph Chung
+
+   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., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+
+#include <stdint.h>
+#include <shlib-compat.h>
+
+#if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_2_6)
+
+symbol_version (__clz_tab_internal, __clz_tab, GLIBC_2.2);
+
+typedef unsigned int UQItype  __attribute__ ((mode (QI)));
+
+const UQItype __clz_tab_internal[] =
+{
+  0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+};
+
+#endif
--- glibc-2.3.2-orig-debian/sysdeps/hppa/sysdep.h	2003-10-22 01:03:47.000000000 -0400
+++ glibc-2.3.2/sysdeps/hppa/sysdep.h	2003-10-22 01:07:38.000000000 -0400
@@ -70,6 +70,7 @@
 #define	PSEUDO_END(name)						      \
   END (name)
 
+#undef JUMPTARGET
 #define JUMPTARGET(name)	name
 #define SYSCALL_PIC_SETUP	/* Nothing.  */
 
--- glibc-2.3.2-orig-debian/sysdeps/posix/getaddrinfo.c	2003-10-22 01:06:12.000000000 -0400
+++ glibc-2.3.2/sysdeps/posix/getaddrinfo.c	2003-10-22 01:07:38.000000000 -0400
@@ -53,6 +53,7 @@
 #include <sys/utsname.h>
 #include <net/if.h>
 #include <nsswitch.h>
+#include <stdbool.h>
 
 #define GAIH_OKIFUNSPEC 0x0100
 #define GAIH_EAI        ~(GAIH_OKIFUNSPEC)
--- glibc-2.3.2-orig-debian/sysdeps/unix/Makefile	2003-10-22 01:06:12.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/Makefile	2003-10-22 01:07:38.000000000 -0400
@@ -295,6 +295,7 @@
 			  $(..)sysdeps/unix/Makefile
 	$(make-target-directory)
 	(echo '#include <errno.h>'; \
+	 echo 'extern long int _no_syscall(void);'; \
 	 echo 'long int _no_syscall (void)'; \
 	 echo '{ __set_errno (ENOSYS); return -1L; }'; \
 	 for call in $(unix-stub-syscalls); do \
--- glibc-2.3.2-orig-debian/sysdeps/unix/sysv/linux/hppa/clone.S	2003-10-22 01:03:48.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/sysv/linux/hppa/clone.S	2003-10-22 01:07:38.000000000 -0400
@@ -28,6 +28,8 @@
 
 /* int clone(int (*fn)(void *arg), void *child_stack, int flags, void *arg) */
 
+#warning CAO: __clone needs verification
+
         .text
 ENTRY(__clone)
 	/* FIXME: I have no idea how profiling works on hppa. */
@@ -42,6 +44,11 @@
 	stwm    %arg0,64(%arg1)
 	stw	%arg3,-60(%arg1)
 
+	/* Save the PIC register. */
+#ifdef PIC
+	stw	%r19,-32(%sr0, %sp)	/* parent */
+#endif
+
 	/* Do the system call */
 	copy	%arg2,%arg0
 	ble     0x100(%sr2,%r0)
@@ -53,19 +60,31 @@
 
 	comib,=,n 0,%ret0,thread_start
 
-	/* Successful return from the parent */
+	/* Successful return from the parent
+	   No need to restore the PIC register, 
+	   since we return immediately. */
+
 	bv	%r0(%rp)
 	nop
 
 	/* Something bad happened -- no child created */
 .Lerror:
+
+	/* Restore the PIC register on error */
+#ifdef PIC
+	ldw	-32(%sr0, %sp), %r19	/* parent */
+#endif
+
 	b	__syscall_error
 	sub     %r0,%ret0,%arg0
 
 thread_start:
+
 	/* Load up the arguments.  */
-	ldw	-60(%sp),%arg0
-	ldw     -64(%sp),%r22
+	ldw	-60(%sr0, %sp),%arg0
+	ldw     -64(%sr0, %sp),%r22
+
+	/* FIXME: Don't touch the childs PIC register? */
 
 	/* Call the user's function */
 	bl	$$dyncall,%r31
--- glibc-2.3.2-orig-debian/sysdeps/unix/sysv/linux/hppa/kernel_stat.h	2003-10-22 01:03:48.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/sysv/linux/hppa/kernel_stat.h	2003-10-22 01:07:38.000000000 -0400
@@ -1,30 +1,30 @@
-/* definition of "struct stat" from the kernel */
+/* Definition of 'struct stat' taken from kernel, please keep up to date */
 struct kernel_stat {
-	unsigned long	st_dev;		/* dev_t is 32 bits on parisc */
-	unsigned long	st_ino;		/* 32 bits */
+	unsigned int	st_dev;		/* dev_t is 32 bits on parisc */
+	unsigned int	st_ino;		/* 32 bits */
 	unsigned short	st_mode;	/* 16 bits */
 	unsigned short	st_nlink;	/* 16 bits */
 	unsigned short	st_reserved1;	/* old st_uid */
 	unsigned short	st_reserved2;	/* old st_gid */
-	unsigned long	st_rdev;
-	unsigned long   st_size;
+	unsigned int	st_rdev;
+	unsigned int	st_size;
 	struct timespec st_atim;
-	struct timespec st_mtim;
-	struct timespec st_ctim;
-	long		st_blksize;
-	long		st_blocks;
-	unsigned long	__unused1;	/* ACL stuff */
-	unsigned long	__unused2;	/* network */
-	unsigned long	__unused3;	/* network */
-	unsigned long	__unused4;	/* cnodes */
+	struct timespec	st_mtim;
+	struct timespec	st_ctim;
+	int		st_blksize;
+	int		st_blocks;
+	unsigned int	__unused1;	/* ACL stuff */
+	unsigned int	__unused2;	/* network */
+	unsigned int	__unused3;	/* network */
+	unsigned int	__unused4;	/* cnodes */
 	unsigned short	__unused5;	/* netsite */
 	short		st_fstype;
-	unsigned long	st_realdev;
+	unsigned int	st_realdev;
 	unsigned short	st_basemode;
 	unsigned short	st_spareshort;
-	unsigned long	st_uid;
-	unsigned long   st_gid;
-	unsigned long	st_spare4[3];
+	unsigned int	st_uid;
+	unsigned int	st_gid;
+	unsigned int	st_spare4[3];
 };
 
 #define _HAVE_STAT_NSEC
--- glibc-2.3.2-orig-debian/sysdeps/unix/sysv/linux/hppa/mmap.c	2003-10-22 01:03:48.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/sysv/linux/hppa/mmap.c	2003-10-22 01:07:38.000000000 -0400
@@ -37,7 +37,7 @@
 	
 	__ptr_t ret;
 
-	ret = INLINE_SYSCALL(mmap, 6, addr, len, prot, flags, fd, offset);
+	ret = (__ptr_t)INLINE_SYSCALL(mmap, 6, addr, len, prot, flags, fd, offset);
 
 	/* check if it's really a negative number */
 	if(((unsigned long)ret & 0xfffff000) == 0xfffff000)
--- glibc-2.3.2-orig-debian/sysdeps/unix/sysv/linux/hppa/sysdep.c	2003-10-22 01:03:48.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/sysv/linux/hppa/sysdep.c	2003-10-22 01:07:38.000000000 -0400
@@ -19,6 +19,10 @@
 #include <sysdep.h>
 #include <errno.h>
 
+extern int __syscall_error(int err_no);
+extern int syscall (int sysnum, int arg0, int arg1, int arg2, 
+			int arg3, int arg4, int arg5);
+
 /* This routine is jumped to by all the syscall handlers, to stash
    an error number into errno.  */
 int
@@ -30,25 +34,31 @@
 
 
 /* HPPA implements syscall() in 'C'; the assembler version would
-   typically be in syscall.S.  */
-
+   typically be in syscall.S. Also note that we have INLINE_SYSCALL,
+   INTERNAL_SYSCALL, and all the generated pure assembly syscall wrappers.
+   How often the function is used is unknown. */
 int
 syscall (int sysnum, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5)
 {
-  long __sys_res;
-  {
-    register unsigned long __res asm("r28");
-    LOAD_ARGS_6(arg0, arg1, arg2, arg3, arg4, arg5)
-      asm volatile ("ble  0x100(%%sr2, %%r0)\n\t"
-		    "copy %1, %%r20"
-		    : "=r" (__res)
-		    : "r" (sysnum) ASM_ARGS_6);
-    __sys_res = __res;
-  }
-  if ((unsigned long) __sys_res >= (unsigned long)-4095)
-    {
-    __set_errno(-__sys_res);
-    __sys_res = -1;
-  }
-  return __sys_res;
+	/* FIXME: Keep this matching INLINE_SYSCALL for hppa */
+	long __sys_res;
+	{
+		register unsigned long __res asm("r28");
+		LOAD_ARGS_6(arg0, arg1, arg2, arg3, arg4, arg5)
+		asm volatile (
+			STW_ASM_PIC
+			"	ble  0x100(%%sr2, %%r0)	\n"
+			"	copy %1, %%r20		\n"
+			LDW_ASM_PIC
+			: "=r" (__res)
+			: "r" (sysnum) ASM_ARGS_6
+			: CALL_CLOB_REGS CLOB_ARGS_6
+		);
+		__sys_res = __res;
+	}
+	if ((unsigned long) __sys_res >= (unsigned long)-4095){
+		__set_errno(-__sys_res);
+		__sys_res = -1;
+	}
+	return __sys_res;
 }
--- glibc-2.3.2-orig-debian/sysdeps/unix/sysv/linux/hppa/sysdep.h	2003-10-22 01:06:12.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/sysv/linux/hppa/sysdep.h	2003-10-22 01:07:38.000000000 -0400
@@ -31,6 +31,26 @@
 #undef SYS_ify
 #define SYS_ify(syscall_name)	(__NR_##syscall_name)
 
+/* Included for older kernels whose headers 
+   are missing the define  */ 
+#ifndef __NR_semtimedop
+# define __NR_semtimedop 228
+#endif
+
+# ifdef PIC
+/* WARNING: CANNOT BE USED IN A NOP! */
+#  define STW_PIC stw %r19, -32(%sr0, %sp) ASM_LINE_SEP
+#  define LDW_PIC ldw -32(%sr0, %sp), %r19 ASM_LINE_SEP
+#  define STW_ASM_PIC	"       copy %%r19, %%r4\n"
+#  define LDW_ASM_PIC	"       copy %%r4, %%r19\n"
+#  define USING_GR4	"%r4",
+# else
+#  define STW_PIC ASM_LINE_SEP
+#  define LDW_PIC ASM_LINE_SEP
+#  define STW_ASM_PIC	" \n"
+#  define LDW_ASM_PIC	" \n"
+#  define USING_GR4
+# endif
 
 #ifdef __ASSEMBLER__
 
@@ -77,20 +97,13 @@
 	.text					ASM_LINE_SEP	\
 	.export C_SYMBOL_NAME(name)		ASM_LINE_SEP	\
 	.type	C_SYMBOL_NAME(name),@function	ASM_LINE_SEP	\
-	C_LABEL(name)						\
-	CALL_MCOUNT
-
-#define ret \
-	bv 0(2)					ASM_LINE_SEP	\
-	nop
-
-#define ret_NOERRNO \
-	bv 0(2)					ASM_LINE_SEP	\
-	nop
+	C_LABEL(name)				ASM_LINE_SEP	\
+	CALL_MCOUNT				ASM_LINE_SEP
 
 #undef	END
-#define END(name)						\
-1:	.size	C_SYMBOL_NAME(name),1b-C_SYMBOL_NAME(name)
+#define END(name)							\
+1:							ASM_LINE_SEP	\
+.size	C_SYMBOL_NAME(name),1b-C_SYMBOL_NAME(name)	ASM_LINE_SEP	\
 
 /* If compiled for profiling, call `mcount' at the start of each function.  */
 /* No, don't bother.  gcc will put the call in for us.  */
@@ -110,27 +123,83 @@
 	nop
 */
 
-#define	PSEUDO(name, syscall_name, args)				      \
-  ENTRY (name)								      \
-  DO_CALL(syscall_name, args)					ASM_LINE_SEP  \
-  nop
+#define	PSEUDO(name, syscall_name, args)			\
+  ENTRY (name)							\
+  DO_CALL(syscall_name, args)			ASM_LINE_SEP	\
+  nop						ASM_LINE_SEP
+
+#define ret \
+	/* Return value set by ERRNO code */	ASM_LINE_SEP	\
+	bv 0(2)					ASM_LINE_SEP	\
+	nop					ASM_LINE_SEP
 
 #undef	PSEUDO_END
-#define	PSEUDO_END(name)						      \
+#define	PSEUDO_END(name)					\
   END (name)
 
-#define	PSEUDO_NOERRNO(name, syscall_name, args)			      \
-  ENTRY (name)								      \
-  DO_CALL(syscall_name, args)					ASM_LINE_SEP  \
-  nop
+/* We don't set the errno on the return from the syscall */
+#define	PSEUDO_NOERRNO(name, syscall_name, args)		\
+  ENTRY (name)							\
+  DO_CALL_NOERRNO(syscall_name, args)		ASM_LINE_SEP	\
+  nop						ASM_LINE_SEP
 
+#define ret_NOERRNO ret 
+  
 #undef	PSEUDO_END_NOERRNO
-#define	PSEUDO_END_NOERRNO(name)					      \
+#define	PSEUDO_END_NOERRNO(name)				\
   END (name)
 
+/* This has to return the error value */
+#undef  PSEUDO_ERRVAL
+#define PSEUDO_ERRVAL(name, syscall_name, args)			\
+	ENTRY(name)						\
+	DO_CALL_ERRVAL(syscall_name, args)	ASM_LINE_SEP	\
+	nop					ASM_LINE_SEP
+
+#define ret_ERRVAL ret
+	
+#undef	PSEUDO_END_ERRVAL
+#define PSEUDO_END_ERRVAL(name)					\
+	END(name)
+
+#undef JUMPTARGET
 #define JUMPTARGET(name)	name
 #define SYSCALL_PIC_SETUP	/* Nothing.  */
 
+	
+/* All the syscall assembly macros rely on finding the approriate 
+   SYSCALL_ERROR_LABEL or rather HANDLER. */
+
+/* int * __errno_location(void) so you have to store your value
+   into the return address! */
+#define DEFAULT_SYSCALL_ERROR_HANDLER 			\
+	.import __errno_location,code	ASM_LINE_SEP	\
+	/* branch to errno handler */	ASM_LINE_SEP	\
+	bl __errno_location,%rp		ASM_LINE_SEP
+	
+/* Here are the myriad of configuration options that the above can
+   work for... what we've done is provide the framework for future
+   changes if required to each section */
+	
+#ifdef PIC
+# if RTLD_PRIVATE_ERRNO
+#  define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER			    
+# else /* !RTLD_PRIVATE_ERRNO */
+#  if defined _LIBC_REENTRANT
+#   define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
+#  else /* !_LIBC_REENTRANT */
+#   define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
+#  endif /* _LIBC_REENTRANT */
+# endif /* RTLD_PRIVATE_ERRNO */
+#else
+# ifndef _LIBC_REENTRANT
+#  define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
+# else
+#  define SYSCALL_ERROR_HANDLER DEFAULT_SYSCALL_ERROR_HANDLER
+# endif
+#endif					
+	
+	
 /* Linux takes system call arguments in registers:
 	syscall number	gr20
 	arg 1		gr26
@@ -159,25 +228,61 @@
 
 #undef	DO_CALL
 #define DO_CALL(syscall_name, args)				\
-	DOARGS_##args						\
+	DOARGS_##args				ASM_LINE_SEP	\
+	STW_PIC					ASM_LINE_SEP	\
+	/* Do syscall, delay loads # */		ASM_LINE_SEP	\
 	ble  0x100(%sr2,%r0)			ASM_LINE_SEP	\
 	ldi SYS_ify (syscall_name), %r20	ASM_LINE_SEP	\
 	ldi -0x1000,%r1				ASM_LINE_SEP	\
 	cmpb,>>=,n %r1,%ret0,0f			ASM_LINE_SEP	\
-	stw %rp, -20(%sr0,%r30)			ASM_LINE_SEP	\
-	stw %ret0, -24(%sr0,%r30)		ASM_LINE_SEP	\
-	.import __errno_location,code		ASM_LINE_SEP	\
-	bl __errno_location,%rp			ASM_LINE_SEP	\
-	ldo 64(%r30), %r30			ASM_LINE_SEP	\
-	ldo -64(%r30), %r30			ASM_LINE_SEP	\
-	ldw -24(%r30), %r26			ASM_LINE_SEP	\
+	/* save rp or we get lost */		ASM_LINE_SEP	\
+	stw %rp, -20(%sr0,%sp)			ASM_LINE_SEP	\
+	/* Restore r19 from frame */		ASM_LINE_SEP	\
+	LDW_PIC					ASM_LINE_SEP	\
+	stw %ret0, -24(%sr0,%sp)		ASM_LINE_SEP	\
+	SYSCALL_ERROR_HANDLER			ASM_LINE_SEP	\
+	/* create frame */			ASM_LINE_SEP	\
+	ldo 64(%sp), %sp			ASM_LINE_SEP	\
+	ldo -64(%sp), %sp			ASM_LINE_SEP	\
+	/* OPTIMIZE: Don't reload r19 */	ASM_LINE_SEP	\
+	/* do a -1*syscall_ret0 */		ASM_LINE_SEP	\
+	ldw -24(%sr0,%sp), %r26			ASM_LINE_SEP	\
 	sub %r0, %r26, %r26			ASM_LINE_SEP	\
+	/* Store into errno location */		ASM_LINE_SEP	\
 	stw %r26, 0(%sr0,%ret0)			ASM_LINE_SEP	\
+	/* return -1 as error */		ASM_LINE_SEP	\
 	ldo -1(%r0), %ret0			ASM_LINE_SEP	\
-	ldw -20(%r30), %rp			ASM_LINE_SEP	\
+	ldw -20(%sr0,%sp), %rp			ASM_LINE_SEP	\
 0:						ASM_LINE_SEP	\
+	UNDOARGS_##args				ASM_LINE_SEP
+
+/* We do nothing with the return, except hand it back to someone else */
+#undef  DO_CALL_NOERRNO
+#define DO_CALL_NOERRNO(syscall_name, args)			\
+	DOARGS_##args                                           \
+	/* No need to store r19 */		ASM_LINE_SEP	\
+	ble  0x100(%sr2,%r0)                    ASM_LINE_SEP    \
+	ldi SYS_ify (syscall_name), %r20        ASM_LINE_SEP    \
+	/* Caller will restore r19 */		ASM_LINE_SEP	\
 	UNDOARGS_##args
 
+/* Here, we return the ERRVAL in assembly, note we don't call the
+   error handler function, but we do 'negate' the return _IF_
+   it's an error. Not sure if this is the right semantic. */
+
+#undef	DO_CALL_ERRVAL
+#define DO_CALL_ERRVAL(syscall_name, args)			\
+	DOARGS_##args				ASM_LINE_SEP	\
+	/* No need to store r19 */		ASM_LINE_SEP	\
+	ble  0x100(%sr2,%r0)			ASM_LINE_SEP	\
+	ldi SYS_ify (syscall_name), %r20	ASM_LINE_SEP	\
+	/* Caller will restore r19 */		ASM_LINE_SEP	\
+	ldi -0x1000,%r1				ASM_LINE_SEP	\
+	cmpb,>>=,n %r1,%ret0,0f			ASM_LINE_SEP	\
+	sub %r0, %ret0, %ret0			ASM_LINE_SEP	\
+0:						ASM_LINE_SEP	\
+	UNDOARGS_##args				ASM_LINE_SEP
+
 #define DOARGS_0 /* nothing */
 #define DOARGS_1 /* nothing */
 #define DOARGS_2 /* nothing */
@@ -198,26 +303,87 @@
 
 #else
 
+/* GCC has to be warned that a syscall may clobber all the ABI 
+   registers listed as "caller-saves", see page 8, Table 2 
+   in section 2.2.6 of the PA-RISC RUN-TIME architecture 
+   document. However! r28 is the result and will conflict with
+   the clobber list so it is left out. Also the input arguments
+   registers r20 -> r26 will conflict with the list so they 
+   are treated specially. Although r19 is clobbered by the syscall
+   we cannot say this because it would violate ABI, thus we say
+   r4 is clobbered and use that register to save/restore r19
+   across the syscall. */
+		 
+#define CALL_CLOB_REGS	"%r1", "%r2", USING_GR4 \
+		 	"%r20", "%r29", "%r31"
+		 
 #undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...)	({		\
+#define INLINE_SYSCALL(name, nr, args...)	({			\
+	long __sys_res;							\
+	{								\
+		register unsigned long __res asm("r28");		\
+		LOAD_ARGS_##nr(args)					\
+		/* FIXME: HACK stw/ldw r19 around syscall */		\
+		asm volatile(						\
+			STW_ASM_PIC					\
+			"	ble  0x100(%%sr2, %%r0)\n"		\
+			"	ldi %1, %%r20\n"			\
+			LDW_ASM_PIC					\
+			: "=r" (__res)					\
+			: "i" (SYS_ify(name)) ASM_ARGS_##nr		\
+			: CALL_CLOB_REGS CLOB_ARGS_##nr			\
+		);							\
+		__sys_res = (long)__res;				\
+	}								\
+	if ( (unsigned long)__sys_res >= (unsigned long)-4095 ){	\
+		__set_errno(-__sys_res);				\
+		__sys_res = -1;						\
+	}								\
+	__sys_res;							\
+})
+
+/* INTERNAL_SYSCALL_DECL - Allows us to setup some function static 
+   value to use within the context of the syscall 
+   INTERNAL_SYSCALL_ERROR_P - Returns 0 if it wasn't an error, 1 otherwise
+   You are allowed to use the syscall result (val) and the DECL error variable
+   to determine what went wrong.
+   INTERLAL_SYSCALL_ERRNO - Munges the val/err pair into the error number.
+   In our case we just flip the sign. */
+
+#undef INTERNAL_SYSCALL_DECL
+#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
+
+/* Equivalent to  (val < 0)&&(val > -4095) which is what we want */
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val, err) \
+	((unsigned long)val >= (unsigned long)-4095)
+	
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
+
+/* Similar to INLINE_SYSCALL but we don't set errno */
+#undef INTERNAL_SYSCALL
+#define INTERNAL_SYSCALL(name, err, nr, args...) 		\
+({								\
 	long __sys_res;						\
 	{							\
 		register unsigned long __res asm("r28");	\
 		LOAD_ARGS_##nr(args)				\
+		/* FIXME: HACK stw/ldw r19 around syscall */	\
 		asm volatile(					\
-			"ble  0x100(%%sr2, %%r0)\n\t"		\
-			" ldi %1, %%r20"			\
+			STW_ASM_PIC				\
+			"	ble  0x100(%%sr2, %%r0)\n"	\
+			"	ldi %1, %%r20\n"		\
+			LDW_ASM_PIC				\
 			: "=r" (__res)				\
 			: "i" (SYS_ify(name)) ASM_ARGS_##nr	\
-			 );					\
-		__sys_res = __res;				\
-	}							\
-	if ((unsigned long)__sys_res >= (unsigned long)-4095) {	\
-		__set_errno(-__sys_res);			\
-		__sys_res = -1;					\
+			: CALL_CLOB_REGS CLOB_ARGS_##nr		\
+		);						\
+		__sys_res = (long)__res;			\
 	}							\
 	__sys_res;						\
-})
+ })
+
 
 #define LOAD_ARGS_0()
 #define LOAD_ARGS_1(r26)					\
@@ -239,12 +405,22 @@
 	register unsigned long __r21 __asm__("r21") = (unsigned long)r21;	\
 	LOAD_ARGS_5(r26,r25,r24,r23,r22)
 
-#define ASM_ARGS_0
-#define ASM_ARGS_1 , "r" (__r26)
-#define ASM_ARGS_2 , "r" (__r26), "r" (__r25)
-#define ASM_ARGS_3 , "r" (__r26), "r" (__r25), "r" (__r24)
-#define ASM_ARGS_4 , "r" (__r26), "r" (__r25), "r" (__r24), "r" (__r23)
-#define ASM_ARGS_5 , "r" (__r26), "r" (__r25), "r" (__r24), "r" (__r23), "r" (__r22)
-#define ASM_ARGS_6 , "r" (__r26), "r" (__r25), "r" (__r24), "r" (__r23), "r" (__r22), "r" (__r21)
-
+/* Even with zero args we use r20 for the syscall number */
+#define ASM_ARGS_0 
+#define ASM_ARGS_1 ASM_ARGS_0, "r" (__r26)
+#define ASM_ARGS_2 ASM_ARGS_1, "r" (__r25)
+#define ASM_ARGS_3 ASM_ARGS_2, "r" (__r24)
+#define ASM_ARGS_4 ASM_ARGS_3, "r" (__r23)
+#define ASM_ARGS_5 ASM_ARGS_4, "r" (__r22)
+#define ASM_ARGS_6 ASM_ARGS_5, "r" (__r21)
+
+/* The registers not listed as inputs but clobbered */
+#define CLOB_ARGS_6
+#define CLOB_ARGS_5 CLOB_ARGS_6, "%r21"
+#define CLOB_ARGS_4 CLOB_ARGS_5, "%r22"
+#define CLOB_ARGS_3 CLOB_ARGS_4, "%r23"
+#define CLOB_ARGS_2 CLOB_ARGS_3, "%r24"
+#define CLOB_ARGS_1 CLOB_ARGS_2, "%r25"
+#define CLOB_ARGS_0 CLOB_ARGS_1, "%r26"
+	
 #endif	/* __ASSEMBLER__ */
--- glibc-2.3.2-orig-debian/sysdeps/unix/sysv/linux/hppa/umount.c	2003-10-22 01:03:48.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/sysv/linux/hppa/umount.c	2003-10-22 01:07:38.000000000 -0400
@@ -21,6 +21,7 @@
    does down here.  */
 
 extern long int __umount2 (const char *name, int flags);
+extern long int __umount (const char * name);
 
 long int
 __umount (const char *name)
--- glibc-2.3.2-orig-debian/sysdeps/unix/sysv/linux/sys/sysctl.h	2003-10-22 01:06:13.000000000 -0400
+++ glibc-2.3.2/sysdeps/unix/sysv/linux/sys/sysctl.h	2003-10-22 01:07:38.000000000 -0400
@@ -24,7 +24,9 @@
 #include <stddef.h>
 /* Prevent more kernel headers than necessary to be included.  */
 #define _LINUX_KERNEL_H	1
-#define _LINUX_TYPES_H	1
+#ifndef _LINUX_TYPES_H
+# define _LINUX_TYPES_H 1
+#endif
 #define _LINUX_LIST_H	1
 /* We do need this one for the declarations in <linux/sysctl.h>,
    since we've elided the inclusion of <linux/kernel.h> that gets them.  */