Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/base/vdso_support.cc

 // Copyright (c) 2008, 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 22 matching lines @@
 // Allow dynamic symbol lookup in the kernel VDSO page.
 //
 // VDSOSupport -- a class representing kernel VDSO (if present).
 //
 
 #include "base/vdso_support.h"
 
 #ifdef HAVE_VDSO_SUPPORT     // defined in vdso_support.h
 
 #include <fcntl.h>
+#include <stddef.h>   // for std::ptrdiff_t
 
 #include "base/atomicops.h"  // for MemoryBarrier
 #include "base/logging.h"
 #include "base/linux_syscall_support.h"
 #include "base/dynamic_annotations.h"
 #include "base/basictypes.h"  // for COMPILE_ASSERT
 
 using base::subtle::MemoryBarrier;
 
 #ifndef AT_SYSINFO_EHDR
@@ skipping 147 matching lines @@
   dynstr_    = NULL;
   versym_    = NULL;
   verdef_    = NULL;
   hash_      = NULL;
   strsize_   = 0;
   verdefnum_ = 0;
   link_base_ = ~0L;  // Sentinel: PT_LOAD .p_vaddr can't possibly be this.
   if (!base) {
     return;
   }
+  const intptr_t base_as_uintptr_t = reinterpret_cast<uintptr_t>(base);
+  // Fake VDSO has low bit set.
+  const bool fake_vdso = ((base_as_uintptr_t & 1) != 0);
+  base = reinterpret_cast<const void *>(base_as_uintptr_t & ~1);
   const char *const base_as_char = reinterpret_cast<const char *>(base);
   if (base_as_char[EI_MAG0] != ELFMAG0 || base_as_char[EI_MAG1] != ELFMAG1 ||
       base_as_char[EI_MAG2] != ELFMAG2 || base_as_char[EI_MAG3] != ELFMAG3) {
     RAW_DCHECK(false, "no ELF magic"); // at %p", base);
     return;
   }
   int elf_class = base_as_char[EI_CLASS];
   if (elf_class != CurrentElfClass::kElfClass) {
     DCHECK_EQ(elf_class, CurrentElfClass::kElfClass);
     return;
@@ skipping 39 matching lines @@
     RAW_DCHECK(dynamic_program_header, "no PT_DYNAMIC in VDSO");
     // Mark this image as not present. Can not recur infinitely.
     Init(0);
     return;
   }
   std::ptrdiff_t relocation =
       base_as_char - reinterpret_cast<const char *>(link_base_);
   ElfW(Dyn) *dynamic_entry =
       reinterpret_cast<ElfW(Dyn) *>(dynamic_program_header->p_vaddr +
                                     relocation);
-  bool fake_vdso = false;  // Assume we are dealing with the real VDSO.
-  for (ElfW(Dyn) *de = dynamic_entry; de->d_tag != DT_NULL; ++de) {
-    ElfW(Sxword) tag = de->d_tag;
-    if (tag == DT_PLTGOT || tag == DT_RELA || tag == DT_JMPREL ||
-        tag == DT_NEEDED || tag == DT_RPATH || tag == DT_VERNEED ||
-        tag == DT_INIT || tag == DT_FINI) {
-      /* Real vdso can not reasonably have any of the above entries.  */
-      fake_vdso = true;
-      break;
-    }
-  }
   for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) {
     ElfW(Xword) value = dynamic_entry->d_un.d_val;
     if (fake_vdso) {
       // A complication: in the real VDSO, dynamic entries are not relocated
       // (it wasn't loaded by a dynamic loader). But when testing with a
       // "fake" dlopen()ed vdso library, the loader relocates some (but
       // not all!) of them before we get here.
       if (dynamic_entry->d_tag == DT_VERDEF) {
         // The only dynamic entry (of the ones we care about) libc-2.3.6
         // loader doesn't relocate.
@@ skipping 98 matching lines @@
     VDSOSupport vdso;
     SymbolInfo info;
     if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
       // Casting from an int to a pointer is not legal C++.  To emphasize
       // this, we use a C-style cast rather than a C++-style cast.
       fn = (GetCpuFn)(info.address);
     }
   }
   // Subtle: this code runs outside of any locks; prevent compiler
   // from assigning to getcpu_fn_ more than once.
-  MemoryBarrier();
+  base::subtle::MemoryBarrier();
   getcpu_fn_ = fn;
   return vdso_base_;
 }
 
 const void *VDSOSupport::SetBase(const void *base) {
   const void *old_base = vdso_base_;
   vdso_base_ = base;
   image_.Init(base);
   // Also reset getcpu_fn_, so GetCPU could be tested with simulated VDSO.
   getcpu_fn_ = &InitAndGetCPU;
@@ skipping 151 matching lines @@
 // ensure it here, with a global constructor of our own.  This
 // is an allowed exception to the normal rule against non-trivial
 // global constructors.
 static class VDSOInitHelper {
  public:
   VDSOInitHelper() { VDSOSupport::Init(); }
 } vdso_init_helper;
 }
 
 #endif  // HAVE_VDSO_SUPPORT