Type profiler by intercepting 'new' and 'delete' expressions.

base/allocator/type_profiler.h

Index: base/allocator/type_profiler.h
diff --git a/base/allocator/type_profiler.h b/base/allocator/type_profiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..babc3d8f4482fac82c984ac6b56465b09fee7301
--- /dev/null
+++ b/base/allocator/type_profiler.h
@@ -0,0 +1,59 @@
+// Copyright 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.
+
+#ifndef BASE_ALLOCATOR_TYPE_PROFILER_H_
+#define BASE_ALLOCATOR_TYPE_PROFILER_H_
+
+#if defined(TYPE_PROFILING)
+
+#include <cstddef>  // for size_t
+#include <typeinfo>  // for std::typeinfo
+
+// These two functions wrap all 'new' and 'delete' expressions.
+// They are called by a modified version of Clang checked-in
+// at deps/third_party/llvm-allocated-type.
+// These prototype declarations are required to make them friends of
+// InterceptFunctions below.
+
+void* __op_new_intercept__(void* ptr,
+                           size_t size,
+                           const std::type_info& type);
+
+void* __op_delete_intercept__(void* ptr,
+                              size_t size,
+                              const std::type_info& type);
+
+namespace base {
+namespace type_profiler {
+
+typedef void* InterceptFunction(void*, size_t, const std::type_info&);
+
+class InterceptFunctions {
+ public:
+  // It must be called only once in a process while it is in single-thread.
+  // For now, ContentMainRunnerImpl::Initialize is the only supposed caller
+  // of this function except for single-threaded unit tests.
+  static void SetFunctions(InterceptFunction* new_intercept,
+                           InterceptFunction* delete_intercept);
+
+ private:
+  friend class TypeProfilerTest;
+  friend void* ::__op_new_intercept__(void*, size_t, const std::type_info&);
+  friend void* ::__op_delete_intercept__(void*, size_t, const std::type_info&);

[jar (doing other things), 2012/09/12 00:34:09]

Why does this require a pre-declaration of the functions?

Is the code snippet in http://en.wikipedia.org/wiki/Friend_function
incorrect? It does not pre-declare friends.

Do we have a compiler option enabled that requires a predeclaration?

[Dai Mikurube (NOT FULLTIME), 2012/09/12 04:26:27]

Clang without any compiler option says as follows for the Wikipedia example:

----------
friend.cc:12:19: error: no function named 'show' with type 'void (A &, B &)' was
found in the specified scope
    friend void ::show(A& x, B& y); // declaration of global friend
                  ^
friend.cc:22:20: error: no function named 'show' with type 'void (A &, B &)' was
found in the specified scope
    friend void  ::show(A& x, B& y); // declaration of global friend
                   ^
friend.cc:38:26: error: 'a' is a private member of 'A'
  cout << "A::a = " << x.a << endl;
                         ^
friend.cc:8:9: note: declared private here
    int a;
        ^
friend.cc:39:26: error: 'b' is a private member of 'B'
  cout << "B::b = " << y.b << endl;
                         ^
friend.cc:18:9: note: declared private here
    int b;
        ^
4 errors generated.
----------

It looks that gcc is just relaxing the spec. 
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf 7.3.1.2p3
looks saying it should have forward declaration.  (This reference is thanks to
Nico.)  In other words, the Wikipedia page may be wrong.

In addition as far as I know, we, the Chromium project, use Clang as a more
accurate C++ syntax checker than gcc.  (The linux_clang bot does it.)

+
+  // These functions are not thread safe.
+  // They must be used only from single-threaded unit tests.
+  static void ResetFunctions();
+  static bool IsAvailable();
+
+  static InterceptFunction* new_intercept_;
+  static InterceptFunction* delete_intercept_;
+};
+
+}  // namespace type_profiler
+}  // namespace base
+
+#endif  // defined(TYPE_PROFILING)
+
+#endif  // BASE_ALLOCATOR_TYPE_PROFILER_H_