Version 3.19.17.

src/mark-compact.cc

 // 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 1477 matching lines @@
 
   static void UpdateRegExpCodeAgeAndFlush(Heap* heap,
                                           JSRegExp* re,
                                           bool is_ascii) {
     // Make sure that the fixed array is in fact initialized on the RegExp.
     // We could potentially trigger a GC when initializing the RegExp.
     if (HeapObject::cast(re->data())->map()->instance_type() !=
             FIXED_ARRAY_TYPE) return;
 
     // Make sure this is a RegExp that actually contains code.
-    if (re->TypeTag() != JSRegExp::IRREGEXP) return;
+    if (re->TypeTagUnchecked() != JSRegExp::IRREGEXP) return;
 
-    Object* code = re->DataAt(JSRegExp::code_index(is_ascii));
+    Object* code = re->DataAtUnchecked(JSRegExp::code_index(is_ascii));
     if (!code->IsSmi() &&
         HeapObject::cast(code)->map()->instance_type() == CODE_TYPE) {
       // Save a copy that can be reinstated if we need the code again.
-      re->SetDataAt(JSRegExp::saved_code_index(is_ascii), code);
+      re->SetDataAtUnchecked(JSRegExp::saved_code_index(is_ascii),
+                             code,
+                             heap);
 
       // Saving a copy might create a pointer into compaction candidate
       // that was not observed by marker.  This might happen if JSRegExp data
       // was marked through the compilation cache before marker reached JSRegExp
       // object.
       FixedArray* data = FixedArray::cast(re->data());
       Object** slot = data->data_start() + JSRegExp::saved_code_index(is_ascii);
       heap->mark_compact_collector()->
           RecordSlot(slot, slot, code);
 
       // Set a number in the 0-255 range to guarantee no smi overflow.
-      re->SetDataAt(JSRegExp::code_index(is_ascii),
-                    Smi::FromInt(heap->sweep_generation() & 0xff));
+      re->SetDataAtUnchecked(JSRegExp::code_index(is_ascii),
+                             Smi::FromInt(heap->sweep_generation() & 0xff),
+                             heap);
     } else if (code->IsSmi()) {
       int value = Smi::cast(code)->value();
       // The regexp has not been compiled yet or there was a compilation error.
       if (value == JSRegExp::kUninitializedValue ||
           value == JSRegExp::kCompilationErrorValue) {
         return;
       }
 
       // Check if we should flush now.
       if (value == ((heap->sweep_generation() - kRegExpCodeThreshold) & 0xff)) {
-        re->SetDataAt(JSRegExp::code_index(is_ascii),
-                      Smi::FromInt(JSRegExp::kUninitializedValue));
-        re->SetDataAt(JSRegExp::saved_code_index(is_ascii),
-                      Smi::FromInt(JSRegExp::kUninitializedValue));
+        re->SetDataAtUnchecked(JSRegExp::code_index(is_ascii),
+                               Smi::FromInt(JSRegExp::kUninitializedValue),
+                               heap);
+        re->SetDataAtUnchecked(JSRegExp::saved_code_index(is_ascii),
+                               Smi::FromInt(JSRegExp::kUninitializedValue),
+                               heap);
       }
     }
   }
 
 
   // Works by setting the current sweep_generation (as a smi) in the
   // code object place in the data array of the RegExp and keeps a copy
   // around that can be reinstated if we reuse the RegExp before flushing.
   // If we did not use the code for kRegExpCodeThreshold mark sweep GCs
   // we flush the code.
@@ skipping 894 matching lines @@
     if (map->IsFreeSpace()) continue;
 
     ASSERT(map->IsMap());
     if (!map->CanTransition()) continue;
 
     if (map_mark.Get() &&
         map->attached_to_shared_function_info()) {
       // This map is used for inobject slack tracking and has been detached
       // from SharedFunctionInfo during the mark phase.
       // Since it survived the GC, reattach it now.
-      JSFunction::cast(map->constructor())->shared()->AttachInitialMap(map);
+      map->unchecked_constructor()->shared()->AttachInitialMap(map);
     }
 
     ClearNonLivePrototypeTransitions(map);
     ClearNonLiveMapTransitions(map, map_mark);
 
     if (map_mark.Get()) {
       ClearNonLiveDependentCode(map);
     } else {
       ClearAndDeoptimizeDependentCode(map);
     }
@@ skipping 10 matching lines @@
   const int proto_offset = header + Map::kProtoTransitionPrototypeOffset;
   const int map_offset = header + Map::kProtoTransitionMapOffset;
   const int step = Map::kProtoTransitionElementsPerEntry;
   for (int i = 0; i < number_of_transitions; i++) {
     Object* prototype = prototype_transitions->get(proto_offset + i * step);
     Object* cached_map = prototype_transitions->get(map_offset + i * step);
     if (IsMarked(prototype) && IsMarked(cached_map)) {
       int proto_index = proto_offset + new_number_of_transitions * step;
       int map_index = map_offset + new_number_of_transitions * step;
       if (new_number_of_transitions != i) {
-        prototype_transitions->set(
+        prototype_transitions->set_unchecked(
+            heap_,
             proto_index,
             prototype,
             UPDATE_WRITE_BARRIER);
-        prototype_transitions->set(
+        prototype_transitions->set_unchecked(
+            heap_,
             map_index,
             cached_map,
             SKIP_WRITE_BARRIER);
       }
       Object** slot =
           HeapObject::RawField(prototype_transitions,
                                FixedArray::OffsetOfElementAt(proto_index));
       RecordSlot(slot, slot, prototype);
       new_number_of_transitions++;
     }
@@ skipping 1818 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal