src/v8/src/heap/objects-visiting.cc

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/v8.h"
   6
   7 #include "src/heap/objects-visiting.h"
   8 #include "src/ic-inl.h"
   9
  10 namespace v8 {
  11 namespace internal {
  12
  13
  14 StaticVisitorBase::VisitorId StaticVisitorBase::GetVisitorId(
  15     int instance_type, int instance_size) {
  16   if (instance_type < FIRST_NONSTRING_TYPE) {
  17     switch (instance_type & kStringRepresentationMask) {
  18       case kSeqStringTag:
  19         if ((instance_type & kStringEncodingMask) == kOneByteStringTag) {
  20           return kVisitSeqOneByteString;
  21         } else {
  22           return kVisitSeqTwoByteString;
  23         }
  24
  25       case kConsStringTag:
  26         if (IsShortcutCandidate(instance_type)) {
  27           return kVisitShortcutCandidate;
  28         } else {
  29           return kVisitConsString;
  30         }
  31
  32       case kSlicedStringTag:
  33         return kVisitSlicedString;
  34
  35       case kExternalStringTag:
  36         return GetVisitorIdForSize(kVisitDataObject, kVisitDataObjectGeneric,
  37                                    instance_size);
  38     }
  39     UNREACHABLE();
  40   }
  41
  42   switch (instance_type) {
  43     case BYTE_ARRAY_TYPE:
  44       return kVisitByteArray;
  45
  46     case FREE_SPACE_TYPE:
  47       return kVisitFreeSpace;
  48
  49     case FIXED_ARRAY_TYPE:
  50       return kVisitFixedArray;
  51
  52     case FIXED_DOUBLE_ARRAY_TYPE:
  53       return kVisitFixedDoubleArray;
  54
  55     case CONSTANT_POOL_ARRAY_TYPE:
  56       return kVisitConstantPoolArray;
  57
  58     case ODDBALL_TYPE:
  59       return kVisitOddball;
  60
  61     case MAP_TYPE:
  62       return kVisitMap;
  63
  64     case CODE_TYPE:
  65       return kVisitCode;
  66
  67     case CELL_TYPE:
  68       return kVisitCell;
  69
  70     case PROPERTY_CELL_TYPE:
  71       return kVisitPropertyCell;
  72
  73     case JS_SET_TYPE:
  74       return GetVisitorIdForSize(kVisitStruct, kVisitStructGeneric,
  75                                  JSSet::kSize);
  76
  77     case JS_MAP_TYPE:
  78       return GetVisitorIdForSize(kVisitStruct, kVisitStructGeneric,
  79                                  JSMap::kSize);
  80
  81     case JS_WEAK_MAP_TYPE:
  82     case JS_WEAK_SET_TYPE:
  83       return kVisitJSWeakCollection;
  84
  85     case JS_REGEXP_TYPE:
  86       return kVisitJSRegExp;
  87
  88     case SHARED_FUNCTION_INFO_TYPE:
  89       return kVisitSharedFunctionInfo;
  90
  91     case JS_PROXY_TYPE:
  92       return GetVisitorIdForSize(kVisitStruct, kVisitStructGeneric,
  93                                  JSProxy::kSize);
  94
  95     case JS_FUNCTION_PROXY_TYPE:
  96       return GetVisitorIdForSize(kVisitStruct, kVisitStructGeneric,
  97                                  JSFunctionProxy::kSize);
  98
  99     case FOREIGN_TYPE:
 100       return GetVisitorIdForSize(kVisitDataObject, kVisitDataObjectGeneric,
 101                                  Foreign::kSize);
 102
 103     case SYMBOL_TYPE:
 104       return kVisitSymbol;
 105
 106     case FILLER_TYPE:
 107       return kVisitDataObjectGeneric;
 108
 109     case JS_ARRAY_BUFFER_TYPE:
 110       return kVisitJSArrayBuffer;
 111
 112     case JS_TYPED_ARRAY_TYPE:
 113       return kVisitJSTypedArray;
 114
 115     case JS_DATA_VIEW_TYPE:
 116       return kVisitJSDataView;
 117
 118     case JS_OBJECT_TYPE:
 119     case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
 120     case JS_GENERATOR_OBJECT_TYPE:
 121     case JS_MODULE_TYPE:
 122     case JS_VALUE_TYPE:
 123     case JS_DATE_TYPE:
 124     case JS_ARRAY_TYPE:
 125     case JS_GLOBAL_PROXY_TYPE:
 126     case JS_GLOBAL_OBJECT_TYPE:
 127     case JS_BUILTINS_OBJECT_TYPE:
 128     case JS_MESSAGE_OBJECT_TYPE:
 129     case JS_SET_ITERATOR_TYPE:
 130     case JS_MAP_ITERATOR_TYPE:
 131     case FLOAT32x4_TYPE:
 132     case FLOAT64x2_TYPE:
 133     case INT32x4_TYPE:
 134       return GetVisitorIdForSize(kVisitJSObject, kVisitJSObjectGeneric,
 135                                  instance_size);
 136     case JS_FUNCTION_TYPE:
 137       return kVisitJSFunction;
 138
 139     case HEAP_NUMBER_TYPE:
 140     case MUTABLE_HEAP_NUMBER_TYPE:
 141 #define EXTERNAL_ARRAY_CASE(Type, type, TYPE, ctype, size) \
 142   case EXTERNAL_##TYPE##_ARRAY_TYPE:
 143
 144       TYPED_ARRAYS(EXTERNAL_ARRAY_CASE)
 145       return GetVisitorIdForSize(kVisitDataObject, kVisitDataObjectGeneric,
 146                                  instance_size);
 147 #undef EXTERNAL_ARRAY_CASE
 148
 149     case FIXED_UINT8_ARRAY_TYPE:
 150     case FIXED_INT8_ARRAY_TYPE:
 151     case FIXED_UINT16_ARRAY_TYPE:
 152     case FIXED_INT16_ARRAY_TYPE:
 153     case FIXED_UINT32_ARRAY_TYPE:
 154     case FIXED_INT32_ARRAY_TYPE:
 155     case FIXED_FLOAT32_ARRAY_TYPE:
 156     case FIXED_INT32x4_ARRAY_TYPE:
 157     case FIXED_FLOAT32x4_ARRAY_TYPE:
 158     case FIXED_FLOAT64x2_ARRAY_TYPE:
 159     case FIXED_UINT8_CLAMPED_ARRAY_TYPE:
 160       return kVisitFixedTypedArray;
 161
 162     case FIXED_FLOAT64_ARRAY_TYPE:
 163       return kVisitFixedFloat64Array;
 164
 165 #define MAKE_STRUCT_CASE(NAME, Name, name) case NAME##_TYPE:
 166       STRUCT_LIST(MAKE_STRUCT_CASE)
 167 #undef MAKE_STRUCT_CASE
 168       if (instance_type == ALLOCATION_SITE_TYPE) {
 169         return kVisitAllocationSite;
 170       }
 171
 172       return GetVisitorIdForSize(kVisitStruct, kVisitStructGeneric,
 173                                  instance_size);
 174
 175     default:
 176       UNREACHABLE();
 177       return kVisitorIdCount;
 178   }
 179 }
 180
 181
 182 // We don't record weak slots during marking or scavenges. Instead we do it
 183 // once when we complete mark-compact cycle.  Note that write barrier has no
 184 // effect if we are already in the middle of compacting mark-sweep cycle and we
 185 // have to record slots manually.
 186 static bool MustRecordSlots(Heap* heap) {
 187   return heap->gc_state() == Heap::MARK_COMPACT &&
 188          heap->mark_compact_collector()->is_compacting();
 189 }
 190
 191
 192 template <class T>
 193 struct WeakListVisitor;
 194
 195
 196 template <class T>
 197 Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer) {
 198   Object* undefined = heap->undefined_value();
 199   Object* head = undefined;
 200   T* tail = NULL;
 201   MarkCompactCollector* collector = heap->mark_compact_collector();
 202   bool record_slots = MustRecordSlots(heap);
 203   while (list != undefined) {
 204     // Check whether to keep the candidate in the list.
 205     T* candidate = reinterpret_cast<T*>(list);
 206     Object* retained = retainer->RetainAs(list);
 207     if (retained != NULL) {
 208       if (head == undefined) {
 209         // First element in the list.
 210         head = retained;
 211       } else {
 212         // Subsequent elements in the list.
 213         DCHECK(tail != NULL);
 214         WeakListVisitor<T>::SetWeakNext(tail, retained);
 215         if (record_slots) {
 216           Object** next_slot =
 217               HeapObject::RawField(tail, WeakListVisitor<T>::WeakNextOffset());
 218           collector->RecordSlot(next_slot, next_slot, retained);
 219         }
 220       }
 221       // Retained object is new tail.
 222       DCHECK(!retained->IsUndefined());
 223       candidate = reinterpret_cast<T*>(retained);
 224       tail = candidate;
 225
 226
 227       // tail is a live object, visit it.
 228       WeakListVisitor<T>::VisitLiveObject(heap, tail, retainer);
 229     } else {
 230       WeakListVisitor<T>::VisitPhantomObject(heap, candidate);
 231     }
 232
 233     // Move to next element in the list.
 234     list = WeakListVisitor<T>::WeakNext(candidate);
 235   }
 236
 237   // Terminate the list if there is one or more elements.
 238   if (tail != NULL) {
 239     WeakListVisitor<T>::SetWeakNext(tail, undefined);
 240   }
 241   return head;
 242 }
 243
 244
 245 template <class T>
 246 static void ClearWeakList(Heap* heap, Object* list) {
 247   Object* undefined = heap->undefined_value();
 248   while (list != undefined) {
 249     T* candidate = reinterpret_cast<T*>(list);
 250     list = WeakListVisitor<T>::WeakNext(candidate);
 251     WeakListVisitor<T>::SetWeakNext(candidate, undefined);
 252   }
 253 }
 254
 255
 256 template <>
 257 struct WeakListVisitor<JSFunction> {
 258   static void SetWeakNext(JSFunction* function, Object* next) {
 259     function->set_next_function_link(next);
 260   }
 261
 262   static Object* WeakNext(JSFunction* function) {
 263     return function->next_function_link();
 264   }
 265
 266   static int WeakNextOffset() { return JSFunction::kNextFunctionLinkOffset; }
 267
 268   static void VisitLiveObject(Heap*, JSFunction*, WeakObjectRetainer*) {}
 269
 270   static void VisitPhantomObject(Heap*, JSFunction*) {}
 271 };
 272
 273
 274 template <>
 275 struct WeakListVisitor<Code> {
 276   static void SetWeakNext(Code* code, Object* next) {
 277     code->set_next_code_link(next);
 278   }
 279
 280   static Object* WeakNext(Code* code) { return code->next_code_link(); }
 281
 282   static int WeakNextOffset() { return Code::kNextCodeLinkOffset; }
 283
 284   static void VisitLiveObject(Heap*, Code*, WeakObjectRetainer*) {}
 285
 286   static void VisitPhantomObject(Heap*, Code*) {}
 287 };
 288
 289
 290 template <>
 291 struct WeakListVisitor<Context> {
 292   static void SetWeakNext(Context* context, Object* next) {
 293     context->set(Context::NEXT_CONTEXT_LINK, next, UPDATE_WRITE_BARRIER);
 294   }
 295
 296   static Object* WeakNext(Context* context) {
 297     return context->get(Context::NEXT_CONTEXT_LINK);
 298   }
 299
 300   static int WeakNextOffset() {
 301     return FixedArray::SizeFor(Context::NEXT_CONTEXT_LINK);
 302   }
 303
 304   static void VisitLiveObject(Heap* heap, Context* context,
 305                               WeakObjectRetainer* retainer) {
 306     // Process the three weak lists linked off the context.
 307     DoWeakList<JSFunction>(heap, context, retainer,
 308                            Context::OPTIMIZED_FUNCTIONS_LIST);
 309     DoWeakList<Code>(heap, context, retainer, Context::OPTIMIZED_CODE_LIST);
 310     DoWeakList<Code>(heap, context, retainer, Context::DEOPTIMIZED_CODE_LIST);
 311   }
 312
 313   template <class T>
 314   static void DoWeakList(Heap* heap, Context* context,
 315                          WeakObjectRetainer* retainer, int index) {
 316     // Visit the weak list, removing dead intermediate elements.
 317     Object* list_head = VisitWeakList<T>(heap, context->get(index), retainer);
 318
 319     // Update the list head.
 320     context->set(index, list_head, UPDATE_WRITE_BARRIER);
 321
 322     if (MustRecordSlots(heap)) {
 323       // Record the updated slot if necessary.
 324       Object** head_slot =
 325           HeapObject::RawField(context, FixedArray::SizeFor(index));
 326       heap->mark_compact_collector()->RecordSlot(head_slot, head_slot,
 327                                                  list_head);
 328     }
 329   }
 330
 331   static void VisitPhantomObject(Heap* heap, Context* context) {
 332     ClearWeakList<JSFunction>(heap,
 333                               context->get(Context::OPTIMIZED_FUNCTIONS_LIST));
 334     ClearWeakList<Code>(heap, context->get(Context::OPTIMIZED_CODE_LIST));
 335     ClearWeakList<Code>(heap, context->get(Context::DEOPTIMIZED_CODE_LIST));
 336   }
 337 };
 338
 339
 340 template <>
 341 struct WeakListVisitor<JSArrayBufferView> {
 342   static void SetWeakNext(JSArrayBufferView* obj, Object* next) {
 343     obj->set_weak_next(next);
 344   }
 345
 346   static Object* WeakNext(JSArrayBufferView* obj) { return obj->weak_next(); }
 347
 348   static int WeakNextOffset() { return JSArrayBufferView::kWeakNextOffset; }
 349
 350   static void VisitLiveObject(Heap*, JSArrayBufferView*, WeakObjectRetainer*) {}
 351
 352   static void VisitPhantomObject(Heap*, JSArrayBufferView*) {}
 353 };
 354
 355
 356 template <>
 357 struct WeakListVisitor<JSArrayBuffer> {
 358   static void SetWeakNext(JSArrayBuffer* obj, Object* next) {
 359     obj->set_weak_next(next);
 360   }
 361
 362   static Object* WeakNext(JSArrayBuffer* obj) { return obj->weak_next(); }
 363
 364   static int WeakNextOffset() { return JSArrayBuffer::kWeakNextOffset; }
 365
 366   static void VisitLiveObject(Heap* heap, JSArrayBuffer* array_buffer,
 367                               WeakObjectRetainer* retainer) {
 368     Object* typed_array_obj = VisitWeakList<JSArrayBufferView>(
 369         heap, array_buffer->weak_first_view(), retainer);
 370     array_buffer->set_weak_first_view(typed_array_obj);
 371     if (typed_array_obj != heap->undefined_value() && MustRecordSlots(heap)) {
 372       Object** slot = HeapObject::RawField(array_buffer,
 373                                            JSArrayBuffer::kWeakFirstViewOffset);
 374       heap->mark_compact_collector()->RecordSlot(slot, slot, typed_array_obj);
 375     }
 376   }
 377
 378   static void VisitPhantomObject(Heap* heap, JSArrayBuffer* phantom) {
 379     Runtime::FreeArrayBuffer(heap->isolate(), phantom);
 380   }
 381 };
 382
 383
 384 template <>
 385 struct WeakListVisitor<AllocationSite> {
 386   static void SetWeakNext(AllocationSite* obj, Object* next) {
 387     obj->set_weak_next(next);
 388   }
 389
 390   static Object* WeakNext(AllocationSite* obj) { return obj->weak_next(); }
 391
 392   static int WeakNextOffset() { return AllocationSite::kWeakNextOffset; }
 393
 394   static void VisitLiveObject(Heap*, AllocationSite*, WeakObjectRetainer*) {}
 395
 396   static void VisitPhantomObject(Heap*, AllocationSite*) {}
 397 };
 398
 399
 400 template Object* VisitWeakList<Code>(Heap* heap, Object* list,
 401                                      WeakObjectRetainer* retainer);
 402
 403
 404 template Object* VisitWeakList<JSFunction>(Heap* heap, Object* list,
 405                                            WeakObjectRetainer* retainer);
 406
 407
 408 template Object* VisitWeakList<Context>(Heap* heap, Object* list,
 409                                         WeakObjectRetainer* retainer);
 410
 411
 412 template Object* VisitWeakList<JSArrayBuffer>(Heap* heap, Object* list,
 413                                               WeakObjectRetainer* retainer);
 414
 415
 416 template Object* VisitWeakList<AllocationSite>(Heap* heap, Object* list,
 417                                                WeakObjectRetainer* retainer);
 418 }
 419 }  // namespace v8::internal