[NOT TO COMMIT!] Replace third_party/tcmalloc/chromium with tcmalloc r136 (the latest).

third_party/tcmalloc/chromium/src/stacktrace_x86-inl.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 47 matching lines @@
 #endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifdef HAVE_MMAP
 #include <sys/mman.h> // for msync
 #include "base/vdso_support.h"
 #endif
 
 #include "google/stacktrace.h"
-#if defined(KEEP_SHADOW_STACKS)
-#include "linux_shadow_stacks.h"
-#endif  // KEEP_SHADOW_STACKS
 
 #if defined(__linux__) && defined(__i386__) && defined(__ELF__) && defined(HAVE_MMAP)
 // Count "push %reg" instructions in VDSO __kernel_vsyscall(),
 // preceeding "syscall" or "sysenter".
 // If __kernel_vsyscall uses frame pointer, answer 0.
 //
 // kMaxBytes tells how many instruction bytes of __kernel_vsyscall
 // to analyze before giving up. Up to kMaxBytes+1 bytes of
 // instructions could be accessed.
 //
@@ skipping 153 matching lines @@
   if (STRICT_UNWINDING) {
     // With the stack growing downwards, older stack frame must be
     // at a greater address that the current one.
     if (new_sp <= old_sp) return NULL;
     // Assume stack frames larger than 100,000 bytes are bogus.
     if ((uintptr_t)new_sp - (uintptr_t)old_sp > 100000) return NULL;
   } else {
     // In the non-strict mode, allow discontiguous stack frames.
     // (alternate-signal-stacks for example).
     if (new_sp == old_sp) return NULL;
-    // And allow frames upto about 1MB.
-    if ((new_sp > old_sp)
-        && ((uintptr_t)new_sp - (uintptr_t)old_sp > 1000000)) return NULL;
+    if (new_sp > old_sp) {
+      // And allow frames upto about 1MB.
+      const uintptr_t delta = (uintptr_t)new_sp - (uintptr_t)old_sp;
+      const uintptr_t acceptable_delta = 1000000;
+      if (delta > acceptable_delta) {
+        return NULL;
+      }
+    }
   }
   if ((uintptr_t)new_sp & (sizeof(void *) - 1)) return NULL;
 #ifdef __i386__
   // On 64-bit machines, the stack pointer can be very close to
   // 0xffffffff, so we explicitly check for a pointer into the
   // last two pages in the address space
   if ((uintptr_t)new_sp >= 0xffffe000) return NULL;
 #endif
 #ifdef HAVE_MMAP
   if (!STRICT_UNWINDING) {
@@ skipping 55 matching lines @@
   //   static void Noop() { asm(""); }  // prevent optimizing-away
   __asm__ volatile ("mov %%rbp, %0" : "=r" (rbp));
   // Arguments are passed in registers on x86-64, so we can't just
   // offset from &result
   sp = (void **) rbp;
 #else
 # error Using stacktrace_x86-inl.h on a non x86 architecture!
 #endif
 
   int n = 0;
-#if defined(KEEP_SHADOW_STACKS)
-  void **shadow_ip_stack;
-  void **shadow_sp_stack;
-  int stack_size;
-  shadow_ip_stack = (void**) get_shadow_ip_stack(&stack_size);
-  shadow_sp_stack = (void**) get_shadow_sp_stack(&stack_size);
-  int shadow_index = stack_size - 1;
-  for (int i = stack_size - 1; i >= 0; i--) {
-    if (sp == shadow_sp_stack[i]) {
-      shadow_index = i;
-      break;
-    }
-  }
-  void **prev_sp = NULL;
-#endif  // KEEP_SHADOW_STACKS
   while (sp && n < max_depth) {
     if (*(sp+1) == reinterpret_cast<void *>(0)) {
       // In 64-bit code, we often see a frame that
       // points to itself and has a return address of 0.
       break;
     }
 #if !IS_WITH_CONTEXT
     const void *const ucp = NULL;
 #endif
     void **next_sp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(sp, ucp);
     if (skip_count > 0) {
       skip_count--;
-#if defined(KEEP_SHADOW_STACKS)
-      shadow_index--;
-#endif  // KEEP_SHADOW_STACKS
     } else {
       result[n] = *(sp+1);
-#if defined(KEEP_SHADOW_STACKS)
-      if ((shadow_index > 0) && (sp == shadow_sp_stack[shadow_index])) {
-        shadow_index--;
-      }
-#endif  // KEEP_SHADOW_STACKS
-
 #if IS_STACK_FRAMES
       if (next_sp > sp) {
         sizes[n] = (uintptr_t)next_sp - (uintptr_t)sp;
       } else {
         // A frame-size of 0 is used to indicate unknown frame size.
         sizes[n] = 0;
       }
 #endif
       n++;
     }
-#if defined(KEEP_SHADOW_STACKS)
-    prev_sp = sp;
-#endif  // KEEP_SHADOW_STACKS
     sp = next_sp;
   }
-
-#if defined(KEEP_SHADOW_STACKS)
-  if (shadow_index >= 0) {
-    for (int i = shadow_index; i >= 0; i--) {
-      if (shadow_sp_stack[i] > prev_sp) {
-        result[n] = shadow_ip_stack[i];
-        if (n + 1 < max_depth) {
-          n++;
-          continue;
-        }
-      }
-      break;
-    }
-  }
-#endif  // KEEP_SHADOW_STACKS
   return n;
 }