[oilpan] Remove GC_INFO_{DEFINE,DECLARE} macros

Source/heap/Visitor.h

Index: Source/heap/Visitor.h
diff --git a/Source/heap/Visitor.h b/Source/heap/Visitor.h
index 25bf88ced6acee0747f8382bcdd16248027d71d2..8d34a1a26989f99ecdf4d357dc578b3e9022f4fd 100644
--- a/Source/heap/Visitor.h
+++ b/Source/heap/Visitor.h
@@ -152,28 +152,10 @@ template<typename T> struct FinalizerTrait {
     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 DEFINE_GC_INFO(Type)                                                  \
-const GCInfo Type::s_gcInfo = {                                               \
-    #Type,                                                                    \
-    TraceTrait<Type>::trace,                                                  \
-    FinalizerTrait<Type>::finalize,                                           \
-    FinalizerTrait<Type>::nonTrivialFinalizer,                                \
-    CLASSOF_FUNC(Type)                                                        \
-};                                                                            \
+#define DECLARE_GC_INFO
+#define DEFINE_GC_INFO(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()
@@ -532,5 +514,30 @@ public:
     }
 };
 
+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