[Mac] Capture -dealloc backtrace to log with CrZombie messages.

base/debug/stack_trace.cc

 // Copyright (c) 2011 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 <algorithm>
+#include <string.h>
+
 namespace base {
 namespace debug {
 
+StackTrace::StackTrace(const void* const* trace, int count) {
+  count = std::min(count, kMaxTraces);

[Scott Hess - ex-Googler, 2011/08/27 05:15:40]

OK, so weird one ... on my 10.6 machine at work running xcode 3.2.1 (yes,
ancient), this compiles.  On my home 10.6 machine running xcode 3.2.6, I get:

Undefined symbols:
  "base::debug::StackTrace::kMaxTraces", referenced from:
      __ZN4base5debug10StackTrace10kMaxTracesE$non_lazy_ptr in
libbase.a(stack_trace.o)
     (maybe you meant: __ZN4base5debug10StackTrace10kMaxTracesE$non_lazy_ptr)
ld: symbol(s) not found

The ways I've worked around it thus far:

 - count = std::min(count, static_cast<int>(kMaxTraces));
 - const int i = kMaxTraces; count = std::min(count, i);
 - if (count > kMaxTraces) count = kMaxTraces;

My best guess is that as coded, the compiler requires a reference to real
memory, which isn't present anywhere.  The work-arounds allow the value to be
inlined everywhere.  Since it's used to size the array, I can't just move the
definition into the implementation file.

There is one more way to solve it:
 - do min(sizeof(trace_), count * sizeof(trace[0])) for memcpy.

This seems least sketchy, as it directly targets the goal (don't overrun
memory!), but I wanted to throw up this discussion in case I've forgotten a C++
case that easily resolves it.

[Scott Hess - ex-Googler, 2011/08/27 05:44:49]

http://en.wikipedia.org/wiki/One_Definition_Rule#Definitions_of_static_const_...
Seems to describe this exact case.  I think.  Of the first workarounds only the
second looks really valid per that description, but the sizeof(trace_)
workaround would still seem to target the goal well, so I'm putting that up.

[Mark Mentovai, 2011/08/28 15:40:01]

I know that you found an answer to your question, but I think that what’s really
going on here is that std::min accepts &reference arguments, and there isn’t
necessarily anything for the reference to refer to when you’re using an integral
static const member variable.

Yes, this is kind of stupid for integral const &references. The compiler COULD
just spit out an int where it needs it and refer to it. But since it isn’t
(wasn’t?) required by the standard, I guess it just wasn’t ever done. Compilers
are actually more lenient in this area than the standard allows them to be, and
a couple of your proposed workarounds took advantage of that fact. I think the
workaround you ultimately used is cleanest, though. And it doesn’t violate the
standard, to boot.

[Scott Hess - ex-Googler, 2011/08/29 20:13:36]

Unfortunately, the code still has to set |count_| to something, so I can't
escape that easily.  I switched it to use min(count, arraysize(trace_)).  Sigh.

+  if (count)
+    memcpy(trace_, trace, count * sizeof(trace[0]));
+  count_ = count;
+}
+
 StackTrace::~StackTrace() {
 }
 
 const void *const *StackTrace::Addresses(size_t* count) const {
   *count = count_;
   if (count_)
     return trace_;
   return NULL;
 }
 
 }  // namespace debug
 }  // namespace base