Experiment for updating the tcmalloc chromium branch to r144 (gperftools 2.0).

third_party/tcmalloc/chromium/src/maybe_threads.cc

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 //
 // Some wrappers for pthread functions so that we can be LD_PRELOADed
 // against non-pthreads apps.
 //
 // This module will behave very strangely if some pthreads functions
 // exist and others don't.
 
 #include "config.h"
 #include <assert.h>
 #include <string.h>    // for memcmp
+#include <stdio.h>     // for __isthreaded on FreeBSD
 // We don't actually need strings. But including this header seems to
 // stop the compiler trying to short-circuit our pthreads existence
 // tests and claiming that the address of a function is always
 // non-zero. I have no idea why ...
 #include <string>
 #include "maybe_threads.h"
 #include "base/basictypes.h"
 
 // __THROW is defined in glibc systems.  It means, counter-intuitively,
 // "This function will never throw an exception."  It's an optional
@@ skipping 39 matching lines @@
 
 int perftools_pthread_setspecific(pthread_key_t key, void *val) {
   if (pthread_setspecific) {
     return pthread_setspecific(key, val);
   } else {
     perftools_pthread_specific_vals[(int)key] = val;
     return 0;
   }
 }
 
+
 static pthread_once_t pthread_once_init = PTHREAD_ONCE_INIT;
 int perftools_pthread_once(pthread_once_t *ctl,
                            void  (*init_routine) (void)) {
+#ifdef __FreeBSD__
+  // On __FreeBSD__, calling pthread_once on a system that is not
+  // linked with -pthread is silently a noop. :-( Luckily, we have a
+  // workaround: FreeBSD exposes __isthreaded in <stdio.h>, which is
+  // set to 1 when the first thread is spawned.  So on those systems,
+  // we can use our own separate pthreads-once mechanism, which is
+  // used until __isthreaded is 1 (which will never be true if the app
+  // is not linked with -pthread).
+  static bool pthread_once_ran_before_threads = false;
+  if (pthread_once_ran_before_threads) {
+    return 0;
+  }
+  if (!__isthreaded) {
+    init_routine();
+    pthread_once_ran_before_threads = true;
+    return 0;
+  }
+#endif
   if (pthread_once) {
     return pthread_once(ctl, init_routine);
   } else {
     if (memcmp(ctl, &pthread_once_init, sizeof(*ctl)) == 0) {
       init_routine();
       ++*(char*)(ctl);        // make it so it's no longer equal to init
     }
     return 0;
   }
 }