Lines Matching refs:Mark
40 #include "mark-compact.h"
385 // If the mark doesn't move, we don't check the color of the object.
740 // Marking all live objects in the heap as part of mark-sweep or mark-compact
755 // the marking stack. Instead, we mark them as both marked and overflowed.
1017 // Mark
1021 // We are close to a stack overflow, so just mark the objects.
1033 MarkBit mark = Marking::MarkBitFrom(cell);
1034 heap->mark_compact_collector()->MarkObject(cell, mark);
1043 MarkBit mark = Marking::MarkBitFrom(object);
1044 heap->mark_compact_collector()->MarkObject(object, mark);
1073 // Mark object pointed to by p.
1080 MarkBit mark = Marking::MarkBitFrom(object);
1081 collector->MarkObject(object, mark);
1094 MarkBit mark = Marking::MarkBitFrom(obj);
1095 heap->mark_compact_collector()->SetMark(obj, mark);
1096 // Mark the map pointer and the body.
1118 MarkBit mark = Marking::MarkBitFrom(obj);
1119 if (mark.Get()) continue;
1170 // Mark the backing hash table without pushing it on the marking stack.
1373 // If we did not use the code for kRegExpCodeThreshold mark sweep GCs
1426 MarkBit mark = Marking::MarkBitFrom(code);
1427 heap->mark_compact_collector()->MarkObject(code, mark);
1732 // Mark the object.
1735 // Mark the map pointer and body, and push them on the marking stack.
1740 // Mark all the objects reachable from the map and body. May leave
1786 // Implementation of WeakObjectRetainer for mark compact GCs. All marked objects
1807 // When map collection is enabled we have to mark through map's transitions
1823 // Mark prototype transitions array but don't push it into marking stack.
1827 MarkBit mark = Marking::MarkBitFrom(prototype_transitions);
1828 if (!mark.Get()) {
1829 mark.Set();
1842 // Mark the Object* fields of the Map.
1882 // EXTERNAL_ARRAY_TRANSITION or NULL_DESCRIPTOR, we don't mark the value as
1887 // a transition or null descriptor, mark the value.
2053 MarkBit mark = Marking::MarkBitFrom(heap_object);
2054 return !mark.Get();
2060 // Mark the symbol table itself.
2063 // Explicitly mark the prefix.
2071 // Mark the heap roots including global variables, stack variables,
2101 MarkBit mark = Marking::MarkBitFrom(heap_object);
2102 if (mark.Get()) {
2114 // An object in the group is marked, so mark as grey all white heap
2120 MarkBit mark = Marking::MarkBitFrom(heap_object);
2121 MarkObject(heap_object, mark);
2149 // A parent object is marked, so mark all child heap objects.
2153 MarkBit mark = Marking::MarkBitFrom(child);
2154 MarkObject(child, mark);
2166 // Mark all objects reachable from the objects on the marking stack.
2185 // Process encountered weak maps, mark objects only reachable by those
2239 // Mark all objects reachable (transitively) from objects on the marking
2275 // Both markers use grey color to mark overflowed objects so
2333 // objects are unmarked. Mark objects reachable due to host
2338 // yet unreachable objects are unmarked. Mark objects reachable
2341 // First we identify nonlive weak handles and mark them as pending
2345 // Then we mark the objects and process the transitive closure.
2352 // Repeat host application specific marking to mark unmarked objects
2363 // marked. Mark the keys for the alive values before we process the
2492 // from SharedFunctionInfo during the mark phase.
2656 heap_->store_buffer()->Mark(dst_slot);
2835 // There are soft limits in the allocation code, designed trigger a mark
2837 // a mark-sweep allocation, there is no sense in trying to trigger one.
2897 // Mark dead objects in the new space with null in their map field.
3195 // are swept lazily and might still have non-zero mark-bits on some
3416 // Visit invalidated code (we ignored all slots on it) and clear mark-bits
3450 // Mark-bit to object start offset table.
3452 // The line is indexed by the mark bits in a byte. The first number on
3636 // Takes a word of mark bits. Returns the number of objects that start in the
3746 // Skip over all the dead objects at the start of the page and mark them free.
3946 // Noncompacting collections simply sweep the spaces to clear the mark
