Recording array buffer views.

src/objects-visiting.h

 // Copyright 2012 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 74 matching lines @@
   V(ConsString)               \
   V(SlicedString)             \
   V(Symbol)                   \
   V(Oddball)                  \
   V(Code)                     \
   V(Map)                      \
   V(PropertyCell)             \
   V(SharedFunctionInfo)       \
   V(JSFunction)               \
   V(JSWeakMap)                \
+  V(JSArrayBuffer)            \
+  V(JSTypedArray)             \
   V(JSRegExp)
 
   // For data objects, JS objects and structs along with generic visitor which
   // can visit object of any size we provide visitors specialized by
   // object size in words.
   // Ids of specialized visitors are declared in a linear order (without
   // holes) starting from the id of visitor specialized for 2 words objects
   // (base visitor id) and ending with the id of generic visitor.
   // Method GetVisitorIdForSize depends on this ordering to calculate visitor
   // id of specialized visitor from given instance size, base visitor id and
@@ skipping 221 matching lines @@
 
   INLINE(static int VisitSeqTwoByteString(Map* map, HeapObject* object)) {
     return SeqTwoByteString::cast(object)->
         SeqTwoByteStringSize(map->instance_type());
   }
 
   INLINE(static int VisitFreeSpace(Map* map, HeapObject* object)) {
     return FreeSpace::cast(object)->Size();
   }
 
+  INLINE(static int VisitJSArrayBuffer(Map* map, HeapObject* object));
+  INLINE(static int VisitJSTypedArray(Map* map, HeapObject* object));
+
   class DataObjectVisitor {
    public:
     template<int object_size>
     static inline int VisitSpecialized(Map* map, HeapObject* object) {
       return object_size;
     }
 
     INLINE(static int Visit(Map* map, HeapObject* object)) {
       return map->instance_size();
     }
@@ skipping 54 matching lines @@
   // Mark non-optimize code for functions inlined into the given optimized
   // code. This will prevent it from being flushed.
   static void MarkInlinedFunctionsCode(Heap* heap, Code* code);
 
  protected:
   INLINE(static void VisitMap(Map* map, HeapObject* object));
   INLINE(static void VisitCode(Map* map, HeapObject* object));
   INLINE(static void VisitSharedFunctionInfo(Map* map, HeapObject* object));
   INLINE(static void VisitJSFunction(Map* map, HeapObject* object));
   INLINE(static void VisitJSRegExp(Map* map, HeapObject* object));
+  INLINE(static void VisitJSArrayBuffer(Map* map, HeapObject* object));
+  INLINE(static void VisitJSTypedArray(Map* map, HeapObject* object));
   INLINE(static void VisitNativeContext(Map* map, HeapObject* object));
 
   // Mark pointers in a Map and its TransitionArray together, possibly
   // treating transitions or back pointers weak.
   static void MarkMapContents(Heap* heap, Map* map);
   static void MarkTransitionArray(Heap* heap, TransitionArray* transitions);
 
   // Code flushing support.
   INLINE(static bool IsFlushable(Heap* heap, JSFunction* function));
   INLINE(static bool IsFlushable(Heap* heap, SharedFunctionInfo* shared_info));
@@ skipping 34 matching lines @@
 
 
 template<typename StaticVisitor>
 VisitorDispatchTable<typename StaticMarkingVisitor<StaticVisitor>::Callback>
     StaticMarkingVisitor<StaticVisitor>::table_;
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_VISITING_H_