Bug 1151118 - Remove recently orphaned tracing paths; r=jonco
authorTerrence Cole <terrence@mozilla.com>
Thu, 02 Apr 2015 09:52:56 -0700
changeset 257321 b91f61e2d950073eea81472c2f6c8c6c7f22b7ca
parent 257320 2982f84319a6f2b9e5d7468a589c3f75902c8b38
child 257322 e1fc8574a62e864d5e2a0c605f0fe621bbfbfd88
push id8007
push userraliiev@mozilla.com
push dateMon, 11 May 2015 19:23:16 +0000
treeherdermozilla-aurora@e2ce1aac996e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjonco
bugs1151118
milestone40.0a1
Bug 1151118 - Remove recently orphaned tracing paths; r=jonco
js/src/gc/Marking.cpp
js/src/gc/Marking.h
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -685,32 +685,16 @@ MarkInternal(JSTracer* trc, T** thingp)
     }
 
     trc->clearTracingDetails();
 }
 
 namespace js {
 namespace gc {
 
-template <typename T>
-void
-MarkUnbarriered(JSTracer* trc, T** thingp, const char* name)
-{
-    trc->setTracingName(name);
-    MarkInternal(trc, thingp);
-}
-
-template <typename T>
-static void
-Mark(JSTracer* trc, BarrieredBase<T*>* thing, const char* name)
-{
-    trc->setTracingName(name);
-    MarkInternal(trc, thing->unsafeGet());
-}
-
 void
 MarkPermanentAtom(JSTracer* trc, JSAtom* atom, const char* name)
 {
     trc->setTracingName(name);
 
     MOZ_ASSERT(atom->isPermanent());
 
     CheckMarkedThing(trc, atom);
@@ -748,56 +732,16 @@ MarkWellKnownSymbol(JSTracer* trc, JS::S
         trc->asCallbackTracer()->invoke(&thing, JSTRACE_SYMBOL);
         MOZ_ASSERT(thing == sym);
         trc->unsetTracingLocation();
     }
 
     trc->clearTracingDetails();
 }
 
-} /* namespace gc */
-} /* namespace js */
-
-template <typename T>
-static void
-MarkRoot(JSTracer* trc, T** thingp, const char* name)
-{
-    JS_ROOT_MARKING_ASSERT(trc);
-    trc->setTracingName(name);
-    MarkInternal(trc, thingp);
-}
-
-template <typename T>
-static void
-MarkRange(JSTracer* trc, size_t len, HeapPtr<T*>* vec, const char* name)
-{
-    for (size_t i = 0; i < len; ++i) {
-        if (vec[i].get()) {
-            trc->setTracingIndex(name, i);
-            MarkInternal(trc, vec[i].unsafeGet());
-        }
-    }
-}
-
-template <typename T>
-static void
-MarkRootRange(JSTracer* trc, size_t len, T** vec, const char* name)
-{
-    JS_ROOT_MARKING_ASSERT(trc);
-    for (size_t i = 0; i < len; ++i) {
-        if (vec[i]) {
-            trc->setTracingIndex(name, i);
-            MarkInternal(trc, &vec[i]);
-        }
-    }
-}
-
-namespace js {
-namespace gc {
-
 template <typename T>
 static inline void
 CheckIsMarkedThing(T* thingp)
 {
 #define IS_SAME_TYPE_OR(name, type) mozilla::IsSame<type*, T>::value ||
     static_assert(
             FOR_EACH_GC_LAYOUT(IS_SAME_TYPE_OR)
             false, "Only the base cell layout types are allowed into marking/tracing internals");
@@ -1011,88 +955,16 @@ UpdateIfRelocated(JSRuntime* rt, T** thi
 
     Zone* zone = (*thingp)->zone();
     if (zone->isGCCompacting() && IsForwarded(*thingp))
         *thingp = Forwarded(*thingp);
 
     return *thingp;
 }
 
-#define DeclMarkerImpl(base, type)                                                                \
-void                                                                                              \
-Mark##base(JSTracer* trc, BarrieredBase<type*>* thing, const char* name)                          \
-{                                                                                                 \
-    Mark<type>(trc, thing, name);                                                                 \
-}                                                                                                 \
-                                                                                                  \
-void                                                                                              \
-Mark##base##Root(JSTracer* trc, type** thingp, const char* name)                                  \
-{                                                                                                 \
-    MarkRoot<type>(trc, thingp, name);                                                            \
-}                                                                                                 \
-                                                                                                  \
-void                                                                                              \
-Mark##base##Unbarriered(JSTracer* trc, type** thingp, const char* name)                           \
-{                                                                                                 \
-    MarkUnbarriered<type>(trc, thingp, name);                                                     \
-}                                                                                                 \
-                                                                                                  \
-/* Explicitly instantiate MarkUnbarriered<type*>. It is referenced from */                        \
-/* other translation units and the instantiation might otherwise get */                           \
-/* inlined away. */                                                                               \
-template void MarkUnbarriered<type>(JSTracer*, type**, const char*);                           \
-                                                                                                  \
-void                                                                                              \
-Mark##base##Range(JSTracer* trc, size_t len, HeapPtr<type*>* vec, const char* name)               \
-{                                                                                                 \
-    MarkRange<type>(trc, len, vec, name);                                                         \
-}                                                                                                 \
-                                                                                                  \
-void                                                                                              \
-Mark##base##RootRange(JSTracer* trc, size_t len, type** vec, const char* name)                    \
-{                                                                                                 \
-    MarkRootRange<type>(trc, len, vec, name);                                                     \
-}                                                                                                 \
-                                                                                                  \
-bool                                                                                              \
-Is##base##Marked(type** thingp)                                                                   \
-{                                                                                                 \
-    return IsMarkedUnbarriered<type*>(thingp);                                                    \
-}                                                                                                 \
-                                                                                                  \
-bool                                                                                              \
-Is##base##Marked(BarrieredBase<type*>* thingp)                                                    \
-{                                                                                                 \
-    return IsMarked<type*>(thingp);                                                               \
-}                                                                                                 \
-                                                                                                  \
-bool                                                                                              \
-Is##base##AboutToBeFinalized(type** thingp)                                                       \
-{                                                                                                 \
-    return IsAboutToBeFinalizedUnbarriered<type*>(thingp);                                        \
-}                                                                                                 \
-                                                                                                  \
-bool                                                                                              \
-Is##base##AboutToBeFinalized(BarrieredBase<type*>* thingp)                                        \
-{                                                                                                 \
-    return IsAboutToBeFinalized<type*>(thingp);                                                   \
-}                                                                                                 \
-                                                                                                  \
-type *                                                                                            \
-Update##base##IfRelocated(JSRuntime* rt, BarrieredBase<type*>* thingp)                            \
-{                                                                                                 \
-    return UpdateIfRelocated<type>(rt, thingp->unsafeGet());                                      \
-}                                                                                                 \
-                                                                                                  \
-type *                                                                                            \
-Update##base##IfRelocated(JSRuntime* rt, type** thingp)                                           \
-{                                                                                                 \
-    return UpdateIfRelocated<type>(rt, thingp);                                                   \
-}
-
 } /* namespace gc */
 } /* namespace js */
 
 /*** Externally Typed Marking ***/
 
 void
 gc::MarkKind(JSTracer* trc, void** thingp, JSGCTraceKind kind)
 {
--- a/js/src/gc/Marking.h
+++ b/js/src/gc/Marking.h
@@ -81,74 +81,16 @@ template <typename T>
 void
 TraceManuallyBarrieredCrossCompartmentEdge(JSTracer* trc, JSObject* src, T* dst,
                                            const char* name);
 
 namespace gc {
 
 /*** Object Marking ***/
 
-/*
- * These functions expose marking functionality for all of the different GC
- * thing kinds. For each GC thing, there are several variants. As an example,
- * these are the variants generated for JSObject. They are listed from most to
- * least desirable for use:
- *
- * MarkObject(JSTracer* trc, const HeapPtrObject& thing, const char* name);
- *     This function should be used for marking JSObjects, in preference to all
- *     others below. Use it when you have HeapPtrObject, which automatically
- *     implements write barriers.
- *
- * MarkObjectRoot(JSTracer* trc, JSObject* thing, const char* name);
- *     This function is only valid during the root marking phase of GC (i.e.,
- *     when MarkRuntime is on the stack).
- *
- * MarkObjectUnbarriered(JSTracer* trc, JSObject* thing, const char* name);
- *     Like MarkObject, this function can be called at any time. It is more
- *     forgiving, since it doesn't demand a HeapPtr as an argument. Its use
- *     should always be accompanied by a comment explaining how write barriers
- *     are implemented for the given field.
- *
- * Additionally, the functions MarkObjectRange and MarkObjectRootRange are
- * defined for marking arrays of object pointers.
- *
- * The following functions are provided to test whether a GC thing is marked
- * under different circumstances:
- *
- * IsObjectAboutToBeFinalized(JSObject** thing);
- *     This function is indended to be used in code used to sweep GC things.  It
- *     indicates whether the object will will be finialized in the current group
- *     of compartments being swept.  Note that this will return false for any
- *     object not in the group of compartments currently being swept, as even if
- *     it is unmarked it may still become marked before it is swept.
- *
- * IsObjectMarked(JSObject** thing);
- *     This function is indended to be used in rare cases in code used to mark
- *     GC things.  It indicates whether the object is currently marked.
- *
- * UpdateObjectIfRelocated(JSObject** thingp);
- *     In some circumstances -- e.g. optional weak marking -- it is necessary
- *     to look at the pointer before marking it strongly or weakly. In these
- *     cases, the following must be called to update the pointer before use.
- */
-
-#define DeclMarker(base, type)                                                                    \
-void Mark##base(JSTracer* trc, BarrieredBase<type*>* thing, const char* name);                    \
-void Mark##base##Root(JSTracer* trc, type** thingp, const char* name);                            \
-void Mark##base##Unbarriered(JSTracer* trc, type** thingp, const char* name);                     \
-void Mark##base##Range(JSTracer* trc, size_t len, HeapPtr<type*>* thing, const char* name);       \
-void Mark##base##RootRange(JSTracer* trc, size_t len, type** thing, const char* name);            \
-bool Is##base##Marked(type** thingp);                                                             \
-bool Is##base##Marked(BarrieredBase<type*>* thingp);                                              \
-bool Is##base##AboutToBeFinalized(type** thingp);                                                 \
-bool Is##base##AboutToBeFinalized(BarrieredBase<type*>* thingp);                                  \
-type* Update##base##IfRelocated(JSRuntime* rt, BarrieredBase<type*>* thingp);                     \
-type* Update##base##IfRelocated(JSRuntime* rt, type** thingp);
-#undef DeclMarker
-
 void
 MarkPermanentAtom(JSTracer* trc, JSAtom* atom, const char* name);
 
 void
 MarkWellKnownSymbol(JSTracer* trc, JS::Symbol* sym);
 
 /* Return true if the pointer is nullptr, or if it is a tagged pointer to
  * nullptr.
@@ -214,26 +156,16 @@ IsAboutToBeFinalizedUnbarriered(T* thing
 template <typename T>
 bool
 IsAboutToBeFinalized(BarrieredBase<T>* thingp);
 
 template <typename T>
 bool
 IsAboutToBeFinalized(ReadBarriered<T>* thingp);
 
-inline bool
-IsAboutToBeFinalized(const js::jit::VMFunction** vmfunc)
-{
-    /*
-     * Preserves entries in the WeakCache<VMFunction, JitCode>
-     * iff the JitCode has been marked.
-     */
-    return false;
-}
-
 inline Cell*
 ToMarkable(const Value& v)
 {
     if (v.isMarkable())
         return (Cell*)v.toGCThing();
     return nullptr;
 }