Keep shadow stacks to help heap checker unwind without frame pointers

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 231 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;
 }