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

third_party/tcmalloc/chromium/src/base/basictypes.h

 // 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 13 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef _BASICTYPES_H_
 #define _BASICTYPES_H_
 
 #include <config.h>
+#include <string.h>       // for memcpy()
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>     // gets us PRId64, etc
 #endif
 
 // To use this in an autoconf setting, make sure you run the following
 // autoconf macros:
 //    AC_HEADER_STDC              /* for stdint_h and inttypes_h */
 //    AC_CHECK_TYPES([__int64])   /* defined in some windows platforms */
 
 #ifdef HAVE_INTTYPES_H
@@ skipping 142 matching lines @@
 
 #define COMPILE_ASSERT(expr, msg)                               \
   typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
 
 #define arraysize(a)  (sizeof(a) / sizeof(*(a)))
 
 #define OFFSETOF_MEMBER(strct, field)                                   \
    (reinterpret_cast<char*>(&reinterpret_cast<strct*>(16)->field) -     \
     reinterpret_cast<char*>(16))
 
+// bit_cast<Dest,Source> implements the equivalent of
+// "*reinterpret_cast<Dest*>(&source)".
+//
+// The reinterpret_cast method would produce undefined behavior
+// according to ISO C++ specification section 3.10 -15 -.
+// bit_cast<> calls memcpy() which is blessed by the standard,
+// especially by the example in section 3.9.
+//
+// Fortunately memcpy() is very fast.  In optimized mode, with a
+// constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline
+// code with the minimal amount of data movement.  On a 32-bit system,
+// memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8)
+// compiles to two loads and two stores.
+
+template <class Dest, class Source>
+inline Dest bit_cast(const Source& source) {
+  COMPILE_ASSERT(sizeof(Dest) == sizeof(Source), bitcasting_unequal_sizes);
+  Dest dest;
+  memcpy(&dest, &source, sizeof(dest));
+  return dest;
+}
+
 #ifdef HAVE___ATTRIBUTE__
 # define ATTRIBUTE_WEAK      __attribute__((weak))
 # define ATTRIBUTE_NOINLINE  __attribute__((noinline))
 #else
 # define ATTRIBUTE_WEAK
 # define ATTRIBUTE_NOINLINE
 #endif
 
 // Section attributes are supported for both ELF and Mach-O, but in
 // very different ways.  Here's the API we provide:
@@ skipping 96 matching lines @@
 # define ATTRIBUTE_SECTION(name)
 # define DECLARE_ATTRIBUTE_SECTION_VARS(name)
 # define INIT_ATTRIBUTE_SECTION_VARS(name)
 # define DEFINE_ATTRIBUTE_SECTION_VARS(name)
 # define ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void*>(0))
 # define ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void*>(0))
 
 #endif  // HAVE___ATTRIBUTE__ and __ELF__ or __MACH__
 
 #if defined(HAVE___ATTRIBUTE__) && (defined(__i386__) || defined(__x86_64__))
-# define CACHELINE_SIZE 64
-# define CACHELINE_ALIGNED __attribute__((aligned(CACHELINE_SIZE)))
+# define CACHELINE_ALIGNED __attribute__((aligned(64)))
 #else
 # define CACHELINE_ALIGNED
 #endif  // defined(HAVE___ATTRIBUTE__) && (__i386__ || __x86_64__)
 
 
 // The following enum should be used only as a constructor argument to indicate
 // that the variable has static storage class, and that the constructor should
 // do nothing to its state.  It indicates to the reader that it is legal to
 // declare a static nistance of the class, provided the constructor is given
 // the base::LINKER_INITIALIZED argument.  Normally, it is unsafe to declare a
 // static variable that has a constructor or a destructor because invocation
 // order is undefined.  However, IF the type can be initialized by filling with
 // zeroes (which the loader does for static variables), AND the destructor also
 // does nothing to the storage, then a constructor declared as
 //       explicit MyClass(base::LinkerInitialized x) {}
 // and invoked as
 //       static MyClass my_variable_name(base::LINKER_INITIALIZED);
 namespace base {
 enum LinkerInitialized { LINKER_INITIALIZED };
 }
 
 #endif  // _BASICTYPES_H_