Workaround ARM tracing issues for non-component builds.

base/debug/stack_trace.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/stack_trace.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <sstream>
 
 #include "base/macros.h"
+#include "base/third_party/symbolize/symbolize.h"
 
 namespace base {
 namespace debug {
 
 StackTrace::StackTrace(const void* const* trace, size_t count) {
   count = std::min(count, arraysize(trace_));
   if (count)
     memcpy(trace_, trace, count * sizeof(trace_[0]));
   count_ = count;
 }
@@ skipping 11 matching lines @@
 std::string StackTrace::ToString() const {
   std::stringstream stream;
 #if !defined(__UCLIBC__)
   OutputToStream(&stream);
 #endif
   return stream.str();
 }
 
 #if HAVE_TRACE_STACK_FRAME_POINTERS
 
+#if defined(OS_ANDROID) && !defined(COMPONENT_BUILD)
+
+#define HAVE_CHROME_CODE_RANGE
+
+bool FindChromeCodeRange(const void** out_start_address,
+                         const void** out_end_address) {
+  struct FindArgs {
+    const void** out_start_address;
+    const void** out_end_address;
+  };
+
+  auto find_callback = [](void* data,
+                          const google::MappedRegion& region) -> bool {
+    const void* region_start_address = reinterpret_cast<const void*>(
+        static_cast<uintptr_t>(region.start_address));
+    const void* region_end_address = reinterpret_cast<const void*>(
+        static_cast<uintptr_t>(region.end_address));
+
+    const void* self_address = reinterpret_cast<const void*>(
+        &FindChromeCodeRange);
+    if (self_address >= region_start_address &&
+        self_address < region_end_address) {
+      FindArgs* args = static_cast<FindArgs*>(data);
+      *args->out_start_address = region_start_address;
+      *args->out_end_address = region_end_address;
+      return true;
+    }
+
+    return false;
+  };
+
+  FindArgs args = {
+      out_start_address,
+      out_end_address
+  };
+  return google::FindMappedRegion(&args, find_callback);
+}
+
+#endif  // !defined(COMPONENT_BUILD)
+
 size_t TraceStackFramePointers(const void** out_trace,
                                size_t max_depth,
                                size_t skip_initial) {
+#if defined(HAVE_CHROME_CODE_RANGE)
+  static const void* chrome_code_start = 0;
+  static const void* chrome_code_end = 0;
+  if (!chrome_code_start || !chrome_code_end) {
+    if (!FindChromeCodeRange(&chrome_code_start, &chrome_code_end)) {
+      // Something went wrong; disable unwinding.
+      chrome_code_start = reinterpret_cast<const void*>(UINTPTR_MAX);
+      chrome_code_end = reinterpret_cast<const void*>(UINTPTR_MAX);
+    }
+  }
+#endif
+
   // Usage of __builtin_frame_address() enables frame pointers in this
   // function even if they are not enabled globally. So 'sp' will always
   // be valid.
   uintptr_t sp = reinterpret_cast<uintptr_t>(__builtin_frame_address(0));
 
   size_t depth = 0;
   while (depth < max_depth) {
 #if defined(__arm__) && defined(__GNUC__) && !defined(__clang__)
     // GCC and LLVM generate slightly different frames on ARM, see
     // https://llvm.org/bugs/show_bug.cgi?id=18505 - LLVM generates
     // x86-compatible frame, while GCC needs adjustment.
     sp -= sizeof(uintptr_t);
 #endif
 
     if (skip_initial != 0) {
       skip_initial--;
     } else {
-      out_trace[depth++] = reinterpret_cast<const void**>(sp)[1];
+#if defined(HAVE_CHROME_CODE_RANGE) && \
+    defined(__clang__) && defined(__thumb__)
+
+      // In thumb fp is r7 and lr is r14, so there can be 1-7 registers
+      // in between.
+      const void* pc;
+      for (size_t i = 1; i <= 7; ++i) {
+        pc = reinterpret_cast<const void**>(sp)[i];
+        if (pc >= chrome_code_start && pc < chrome_code_end) {
+          // Looks like code, use it.
+          break;
+        }
+        pc = nullptr;
+      }
+      if (!pc) {
+        // Didn't find anything, stop unwinding.
+        break;
+      }
+      out_trace[depth++] = pc;
+
+#else
+
+      // In arm mode we have proper stack frames, so lr always follows fp.
+      const void* pc = reinterpret_cast<const void**>(sp)[1];
+      out_trace[depth++] = pc;
+#if defined(HAVE_CHROME_CODE_RANGE)
+      if (pc < chrome_code_start || pc >= chrome_code_end) {
+        // Stop unwinding after first non-Chrome PC - it's either bogus,
+        // or from a system library. But since system libraries on Android
+        // and Linux are built without frame pointers, there is no point
+        // diving into them.
+        break;
+      }
+#endif
+
+#endif  // HAVE_CHROME_CODE_RANGE && __clang__ && __thumb__
     }
 
     // Find out next frame pointer
     // (heuristics are from TCMalloc's stacktrace functions)
     {
       uintptr_t next_sp = reinterpret_cast<const uintptr_t*>(sp)[0];
 
       // With the stack growing downwards, older stack frame must be
       // at a greater address that the current one.
       if (next_sp <= sp) break;
 
       // Assume stack frames larger than 100,000 bytes are bogus.
       if (next_sp - sp > 100000) break;
 
       // Check alignment.
       if (sp & (sizeof(void*) - 1)) break;
 
       sp = next_sp;
     }
   }
 
   return depth;
 }
 
 #endif  // HAVE_TRACE_STACK_FRAME_POINTERS
 
 }  // namespace debug
 }  // namespace base