[oilpan] Remove GC_INFO_{DEFINE,DECLARE} macros

Source/heap/Visitor.h

 /*
  * Copyright (C) 2013 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 134 matching lines @@
 struct FinalizerTraitImpl<T, false> {
     static void finalize(void* obj) { };
 };
 
 // Default trait uses the automatic detection.
 template<typename T> struct FinalizerTrait {
     static const bool nonTrivialFinalizer = HasFinalizer<T>::value;
     static void finalize(void* obj) { FinalizerTraitImpl<T, nonTrivialFinalizer>::finalize(obj); }
 };
 
-#define DECLARE_GC_INFO                                                       \
-public:                                                                       \
-    static const GCInfo s_gcInfo;                                             \
-    template<typename Any> friend struct FinalizerTrait;                      \
-private:                                                                      \
+#define DECLARE_GC_INFO
+#define DEFINE_GC_INFO(Type)
 
-#define DEFINE_GC_INFO(Type)                                                  \
-const GCInfo Type::s_gcInfo = {                                               \
-    #Type,                                                                    \
-    TraceTrait<Type>::trace,                                                  \
-    FinalizerTrait<Type>::finalize,                                           \
-    FinalizerTrait<Type>::nonTrivialFinalizer,                                \
-    CLASSOF_FUNC(Type)                                                        \
-};                                                                            \
-
-template<typename T>
-struct GCInfoTrait {
-    static const GCInfo* get()
-    {
-        return &T::s_gcInfo;
-    }
-};
+template<typename T> struct GCInfoTrait;
 
 template<typename T>
 const char* getTypeMarker()
 {
     return GCInfoTrait<T>::get()->m_typeMarker;
 }
 
 // Most classes that have instances on the heap have an trace method, which is
 // used to trace the pointers to other heap objects inside an object.
 template<typename T>
@@ skipping 338 matching lines @@
 }
 
 class HeapVisitable {
 public:
     virtual void trace(Visitor*) = 0;
     virtual ~HeapVisitable()
     {
     }
 };
 
+template<typename T>
+struct GCInfoAtBase {
+    static const GCInfo* get()
+    {
+        static char foo = 'a'; // FIXME

[haraken, 2014/02/19 02:51:40]

foo => type (or className)

Add more description.

[kouhei (in TOK), 2014/02/19 03:08:20]

@Slava
I want your suggestions here. I'm not sure how we should handle |m_markerType|
here.

This passes tests, but breaks some debug outputs relying on the fact
m_typeMarker == #T.

Some options are:
1. Remove |m_markerType|, and replace its comparisons with &gcInfo comparisons.
2. Introduce something like |extractNameFromFunctionName()| on DEBUG builds. Use
some random unique address on RELEASE.

[zerny-chromium, 2014/02/19 09:44:48]

We only need the type marker on debug builds so we can simply remove it
completely from the gcInfo struct on release builds.

For now we need the type marker for at least debug builds with gcc and clang. Do
you know if we can get an |extractNameFromFunctionName()| working for debug on
windows builds too? Would be nice, but it's not as important as the other two.

[kouhei (in TOK), 2014/02/19 11:57:27]

Thanks for your comment.

Just to clarify, the above &foo will also work on debug, and pass all ASSERTs.
It just breaks some debug message outputs.

I'm not sure why CLASSOF_FUNC(T) and #T are both needed.

[Vyacheslav Egorov (Chromium), 2014/02/19 15:03:31]

CLASSOF_FUNC could delegate to a virtual classOf method that could return a
result more precise than #T (e.g. for Node #T is always Node as a root, but
classOf can return more precise node type).

Given that we ripped off the GC tracing on the trunk branch we should ignore the
issue for now and be satisfied with a random address.

Strictly speaking I would go as far as saying that we should be able to kill
typeMarker entirely because address of the gcInfo itself works as a type marker.
Type markers were introduced prior to introduction of gcInfo and served as a way
to verify consistency between dynamic types and static types of handles. Now
gcInfo address can be used for the same purpose.

Now if we ever want to resurrect GC tracing we can extract type name from
__PRETTY_FUNCTION_ on both gcc and clang and from __FUNCSIG__ on MS CL compiler,
so I think we will be fine.



On 2014/02/19 11:57:27, kouhei wrote:

[kouhei (in TOK), 2014/02/20 01:07:41]

Thanks, Slava!
I'll split work and do the following
1. Land this CL, with |foo| renamed to |pseudoTypeMarker|.
2. Remove all macros CL
3. Remove type marker and use &gcInfo CL.

+        static const GCInfo gcInfo = {
+            &foo,
+            TraceTrait<T>::trace,
+            FinalizerTrait<T>::finalize,
+            FinalizerTrait<T>::nonTrivialFinalizer,
+            CLASSOF_FUNC(T)
+        };
+        return &gcInfo;
+    }
+};
+
+template<typename T>
+struct GCInfoTrait {
+    static const GCInfo* get()
+    {
+        return GCInfoAtBase<typename T::HeapAllocatedBase>::get();
+    }
+};
+
 }
+
 #endif