Adds TCMalloc support for Android.

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 106 matching lines @@
   }
   if (!__isthreaded) {
     init_routine();
     pthread_once_ran_before_threads = true;
     return 0;
   }
 #endif
   if (pthread_once) {
     return pthread_once(ctl, init_routine);
   } else {
+#if defined(__ANDROID__)
+    // Android's pthread_once_t is typedef volatile and memcmp only takes

[Jeffrey Yasskin, 2013/05/21 17:09:43]

Are there any situations where Android is missing pthread_once? That is, can you
replace this branch with a CHECK on Android? 

[digit1, 2013/05/21 18:16:24]

No, pthread_once() and pthread_once_t are definitely provided by the Android C
library when targetting Gingerbread (2.3) or higher. I'm not sure why this block
is needed. Without memory barriers, it won't work properly anyway on multi-core
devices.

[bulach, 2013/05/22 07:41:41]

thanks both! so it seems pthread_once is guaranteed to exist, the "else" branch
and that crazy cast is not necessary on android. removed it.

+    // const void*, cast the volatile away.
+    if (memcmp(const_cast<const void*>(reinterpret_cast<const volatile void*>(

[Jeffrey Yasskin, 2013/05/21 17:09:43]

http://goto.google.com/c++03pdf [dcl.type.cv]p7 says, "If an attempt is made to
refer to an object defined with a volatile-qualified type through the use of an
lvalue with a non-volatile-qualified type, the program behaviour is undefined.",
so you should write the char-comparing loop instead of using memcpy if you
really need to compare by bytes.

In future changes, you shouldn't use reinterpret_cast to go to void*. Either use
a c-style cast directly to (const void*) or implicit-cast to const volatile
void* ("const volatile void* void_ctl = ctl;"), and then const_cast to const
void*. If you really like the 1-line option, and tcmalloc doesn't define the
implicit_cast<> template
(https://code.google.com/p/chromium/codesearch/#chromium/src/base/basictypes.h...),
use a static_cast.

[Dai Mikurube (NOT FULLTIME), 2013/05/21 17:21:46]

A comment from a side:

It's just a local change to the third party library gperftools (tcmalloc).  I
believe that we should follow the original's code convention in such a case and
we shouldn't have large changes from the original code in Chromium.

We may upstream this change to the original.  We may want to discuss it at that
time.

[Dai Mikurube (NOT FULLTIME), 2013/05/21 17:26:12]

Hmm, sorry.  I might make a misunderstanding of your comments.  Please ignore
it.

[bulach, 2013/05/22 07:41:41]

thanks jeffrey! yeah, one of the previous patches here used the c-style cast,
but reviewers preferred to stick c++ style...
thankfully this is all removed anyways. :)

+                   ctl)),
+               const_cast<const void*>(reinterpret_cast<const volatile void*>(
+                   &pthread_once_init)),
+               sizeof(*ctl)) == 0) {
+#else
     if (memcmp(ctl, &pthread_once_init, sizeof(*ctl)) == 0) {
+#endif
       init_routine();
       ++*(char*)(ctl);        // make it so it's no longer equal to init
     }
     return 0;
   }
 }