Update libxml to 2.7.7.

third_party/libxml/threads.c

 /**
- * threads.c: set of generic threading related routines 
+ * threads.c: set of generic threading related routines
  *
  * See Copyright for the status of this software.
  *
  * Gary Pennington <Gary.Pennington@uk.sun.com>
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
 #include "libxml.h"
 
 #include <string.h>
 
 #include <libxml/threads.h>
 #include <libxml/globals.h>
 
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 #ifdef HAVE_PTHREAD_H
 #include <pthread.h>
-#endif
-
-#ifdef HAVE_WIN32_THREADS
+#elif defined HAVE_WIN32_THREADS
 #include <windows.h>
 #ifndef HAVE_COMPILER_TLS
 #include <process.h>
 #endif
 #endif
 
 #ifdef HAVE_BEOS_THREADS
 #include <OS.h>
 #include <TLS.h>
 #endif
@@ skipping 14 matching lines @@
                          void (*__init_routine) (void))
            __attribute((weak));
 extern void *pthread_getspecific (pthread_key_t __key)
            __attribute((weak));
 extern int pthread_setspecific (pthread_key_t __key,
                                 __const void *__pointer)
            __attribute((weak));
 extern int pthread_key_create (pthread_key_t *__key,
                                void (*__destr_function) (void *))
            __attribute((weak));
+extern int pthread_key_delete (pthread_key_t __key)
+           __attribute((weak));
 extern int pthread_mutex_init ()
            __attribute((weak));
 extern int pthread_mutex_destroy ()
            __attribute((weak));
 extern int pthread_mutex_lock ()
            __attribute((weak));
 extern int pthread_mutex_unlock ()
            __attribute((weak));
 extern int pthread_cond_init ()
            __attribute((weak));
+extern int pthread_cond_destroy ()
+           __attribute((weak));
+extern int pthread_cond_wait ()
+           __attribute((weak));
 extern int pthread_equal ()
            __attribute((weak));
 extern pthread_t pthread_self ()
            __attribute((weak));
 extern int pthread_key_create ()
            __attribute((weak));
+extern int pthread_key_delete ()
+           __attribute((weak));
 extern int pthread_cond_signal ()
            __attribute((weak));
 #endif
 #endif /* linux */
 #endif /* __GNUC__ */
 #endif /* HAVE_PTHREAD_H */
 
 /*
  * TODO: this module still uses malloc/free and not xmlMalloc/xmlFree
  *       to avoid some crazyness since xmlMalloc/xmlFree may actually
@@ skipping 305 matching lines @@
         return;
 #ifdef HAVE_PTHREAD_H
     if (libxml_is_threaded == 0)
         return;
 
     pthread_mutex_lock(&tok->lock);
     tok->held--;
     if (tok->held == 0) {
         if (tok->waiters)
             pthread_cond_signal(&tok->cv);
-        tok->tid = 0;
+        memset(&tok->tid, 0, sizeof(tok->tid));
     }
     pthread_mutex_unlock(&tok->lock);
 #elif defined HAVE_WIN32_THREADS
     if (!--tok->count)
         LeaveCriticalSection(&tok->cs);
 #elif defined HAVE_BEOS_THREADS
     if (tok->lock->tid == find_thread(NULL)) {
         tok->count--;
         if (tok->count == 0) {
             xmlMutexUnlock(tok->lock);
@@ skipping 96 matching lines @@
 
 /**
  * xmlGlobalInitMutexDestroy
  *
  * Makes sure that the global initialization mutex is destroyed before
  * application termination.
  */
 void
 __xmlGlobalInitMutexDestroy(void)
 {
-#if defined HAVE_WIN32_THREADS
+#ifdef HAVE_PTHREAD_H
+#elif defined HAVE_WIN32_THREADS
     if (global_init_lock != NULL) {
         DeleteCriticalSection(global_init_lock);
         free(global_init_lock);
         global_init_lock = NULL;
     }
 #endif
 }
 
 /************************************************************************
  *                                                                      *
@@ skipping 43 matching lines @@
                         "xmlGetGlobalState: out of memory\n");
         return (NULL);
     }
 
     memset(gs, 0, sizeof(xmlGlobalState));
     xmlInitializeGlobalState(gs);
     return (gs);
 }
 #endif /* LIBXML_THREAD_ENABLED */
 
-
-#ifdef HAVE_WIN32_THREADS
+#ifdef HAVE_PTHREAD_H
+#elif defined HAVE_WIN32_THREADS
 #if !defined(HAVE_COMPILER_TLS)
 #if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
 typedef struct _xmlGlobalStateCleanupHelperParams {
     HANDLE thread;
     void *memory;
 } xmlGlobalStateCleanupHelperParams;
 
 static void XMLCDECL
 xmlGlobalStateCleanupHelper(void *p)
 {
@@ skipping 87 matching lines @@
     if (globalval == NULL) {
         xmlGlobalState *tsd = xmlNewGlobalState();
 
         if (tsd == NULL)
             return(NULL);
         p = (xmlGlobalStateCleanupHelperParams *)
             malloc(sizeof(xmlGlobalStateCleanupHelperParams));
         if (p == NULL) {
             xmlGenericError(xmlGenericErrorContext,
                             "xmlGetGlobalState: out of memory\n");
+            xmlFreeGlobalState(tsd);
             return(NULL);
         }
         p->memory = tsd;
 #if defined(LIBXML_STATIC) && !defined(LIBXML_STATIC_FOR_DLL)
         DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
                         GetCurrentProcess(), &p->thread, 0, TRUE,
                         DUPLICATE_SAME_ACCESS);
         TlsSetValue(globalkey, tsd);
         _beginthread(xmlGlobalStateCleanupHelper, 0, p);
 #else
@@ skipping 35 matching lines @@
 /************************************************************************
  *                                                                      *
  *                      Library wide thread interfaces                  *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlGetThreadId:
  *
  * xmlGetThreadId() find the current thread ID number
+ * Note that this is likely to be broken on some platforms using pthreads
+ * as the specification doesn't mandate pthread_t to be an integer type
  *
  * Returns the current thread ID number
  */
 int
 xmlGetThreadId(void)
 {
 #ifdef HAVE_PTHREAD_H
+    pthread_t id;
+    int ret;
+
     if (libxml_is_threaded == 0)
         return (0);
-    return ((int) pthread_self());
+    id = pthread_self();
+    /* horrible but preserves compat, see warning above */
+    memcpy(&ret, &id, sizeof(ret));
+    return (ret);
 #elif defined HAVE_WIN32_THREADS
     return GetCurrentThreadId();
 #elif defined HAVE_BEOS_THREADS
     return find_thread(NULL);
 #else
     return ((int) 0);
 #endif
 }
 
 /**
@@ skipping 15 matching lines @@
 #elif defined HAVE_WIN32_THREADS
     xmlOnceInit();
 #elif defined HAVE_BEOS_THREADS
     xmlOnceInit();
 #endif
 
 #ifdef DEBUG_THREADS
     xmlGenericError(xmlGenericErrorContext, "xmlIsMainThread()\n");
 #endif
 #ifdef HAVE_PTHREAD_H
-    return (mainthread == pthread_self());
+    return (pthread_equal(mainthread,pthread_self()));
 #elif defined HAVE_WIN32_THREADS
     return (mainthread == GetCurrentThreadId());
 #elif defined HAVE_BEOS_THREADS
     return (mainthread == find_thread(NULL));
 #else
     return (1);
 #endif
 }
 
 /**
@@ skipping 28 matching lines @@
 
 /**
  * xmlInitThreads:
  *
  * xmlInitThreads() is used to to initialize all the thread related
  * data of the libxml2 library.
  */
 void
 xmlInitThreads(void)
 {
-#ifdef DEBUG_THREADS
-    xmlGenericError(xmlGenericErrorContext, "xmlInitThreads()\n");
-#endif
-#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
-    InitializeCriticalSection(&cleanup_helpers_cs);
-#endif
 #ifdef HAVE_PTHREAD_H
     if (libxml_is_threaded == -1) {
         if ((pthread_once != NULL) &&
             (pthread_getspecific != NULL) &&
             (pthread_setspecific != NULL) &&
             (pthread_key_create != NULL) &&
+            (pthread_key_delete != NULL) &&
             (pthread_mutex_init != NULL) &&
             (pthread_mutex_destroy != NULL) &&
             (pthread_mutex_lock != NULL) &&
             (pthread_mutex_unlock != NULL) &&
             (pthread_cond_init != NULL) &&
+            (pthread_cond_destroy != NULL) &&
+            (pthread_cond_wait != NULL) &&
             (pthread_equal != NULL) &&
             (pthread_self != NULL) &&
             (pthread_cond_signal != NULL)) {
             libxml_is_threaded = 1;
 
 /* fprintf(stderr, "Running multithreaded\n"); */
         } else {
 
 /* fprintf(stderr, "Running without multithread\n"); */
             libxml_is_threaded = 0;
         }
     }
+#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
+    InitializeCriticalSection(&cleanup_helpers_cs);
 #endif
 }
 
 /**
  * xmlCleanupThreads:
  *
  * xmlCleanupThreads() is used to to cleanup all the thread related
  * data of the libxml2 library once processing has ended.
+ *
+ * WARNING: if your application is multithreaded or has plugin support
+ *          calling this may crash the application if another thread or
+ *          a plugin is still using libxml2. It's sometimes very hard to
+ *          guess if libxml2 is in use in the application, some libraries
+ *          or plugins may use it without notice. In case of doubt abstain
+ *          from calling this function or do it just before calling exit()
+ *          to avoid leak reports from valgrind !
  */
 void
 xmlCleanupThreads(void)
 {
 #ifdef DEBUG_THREADS
     xmlGenericError(xmlGenericErrorContext, "xmlCleanupThreads()\n");
 #endif
-#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
+#ifdef HAVE_PTHREAD_H
+    if ((libxml_is_threaded)  && (pthread_key_delete != NULL))
+        pthread_key_delete(globalkey);
+#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
     if (globalkey != TLS_OUT_OF_INDEXES) {
         xmlGlobalStateCleanupHelperParams *p;
 
         EnterCriticalSection(&cleanup_helpers_cs);
         p = cleanup_helpers_head;
         while (p != NULL) {
             xmlGlobalStateCleanupHelperParams *temp = p;
 
             p = p->next;
             xmlFreeGlobalState(temp->memory);
@@ skipping 18 matching lines @@
  * pthread_once() in association with the once_control variable to ensure
  * that the function is only called once. See man pthread_once for more
  * details.
  */
 static void
 xmlOnceInit(void)
 {
 #ifdef HAVE_PTHREAD_H
     (void) pthread_key_create(&globalkey, xmlFreeGlobalState);
     mainthread = pthread_self();
-#endif
-
-#if defined(HAVE_WIN32_THREADS)
+#elif defined(HAVE_WIN32_THREADS)
     if (!run_once.done) {
         if (InterlockedIncrement(&run_once.control) == 1) {
 #if !defined(HAVE_COMPILER_TLS)
             globalkey = TlsAlloc();
 #endif
             mainthread = GetCurrentThreadId();
             run_once.done = 1;
         } else {
             /* Another thread is working; give up our slice and
              * wait until they're done. */
             while (!run_once.done)
                 Sleep(0);
         }
     }
-#endif
-
-#ifdef HAVE_BEOS_THREADS
+#elif defined HAVE_BEOS_THREADS
     if (atomic_add(&run_once_init, 1) == 0) {
         globalkey = tls_allocate();
         tls_set(globalkey, NULL);
         mainthread = find_thread(NULL);
     } else
         atomic_add(&run_once_init, -1);
 #endif
 }
 #endif
 
 /**
  * DllMain:
  * @hinstDLL: handle to DLL instance
  * @fdwReason: Reason code for entry
  * @lpvReserved: generic pointer (depends upon reason code)
  *
  * Entry point for Windows library. It is being used to free thread-specific
  * storage.
  *
  * Returns TRUE always
  */
-#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
+#ifdef HAVE_PTHREAD_H
+#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
 #if defined(LIBXML_STATIC_FOR_DLL)
 BOOL XMLCALL
 xmlDllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 #else
 BOOL WINAPI
 DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 #endif
 {
     switch (fdwReason) {
         case DLL_THREAD_DETACH:
@@ skipping 19 matching lines @@
                     free(p);
                 }
             }
             break;
     }
     return TRUE;
 }
 #endif
 #define bottom_threads
 #include "elfgcchack.h"