Revert to code state of 3.13.1 plus r12350

src/incremental-marking.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 611 matching lines @@
 void IncrementalMarking::Hurry() {
   if (state() == MARKING) {
     double start = 0.0;
     if (FLAG_trace_incremental_marking) {
       PrintF("[IncrementalMarking] Hurry\n");
       start = OS::TimeCurrentMillis();
     }
     // TODO(gc) hurry can mark objects it encounters black as mutator
     // was stopped.
     Map* filler_map = heap_->one_pointer_filler_map();
-    Map* native_context_map = heap_->native_context_map();
+    Map* global_context_map = heap_->global_context_map();
     while (!marking_deque_.IsEmpty()) {
       HeapObject* obj = marking_deque_.Pop();
 
       // Explicitly skip one word fillers. Incremental markbit patterns are
       // correct only for objects that occupy at least two words.
       Map* map = obj->map();
       if (map == filler_map) {
         continue;
-      } else if (map == native_context_map) {
-        // Native contexts have weak fields.
-        IncrementalMarkingMarkingVisitor::VisitNativeContext(map, obj);
+      } else if (map == global_context_map) {
+        // Global contexts have weak fields.
+        IncrementalMarkingMarkingVisitor::VisitGlobalContext(map, obj);
       } else if (map->instance_type() == MAP_TYPE) {
         Map* map = Map::cast(obj);
         heap_->ClearCacheOnMap(map);
 
         // When map collection is enabled we have to mark through map's
         // transitions and back pointers in a special way to make these links
         // weak.  Only maps for subclasses of JSReceiver can have transitions.
         STATIC_ASSERT(LAST_TYPE == LAST_JS_RECEIVER_TYPE);
         if (FLAG_collect_maps &&
             map->instance_type() >= FIRST_JS_RECEIVER_TYPE) {
@@ skipping 25 matching lines @@
     }
   }
 
   if (FLAG_cleanup_code_caches_at_gc) {
     PolymorphicCodeCache* poly_cache = heap_->polymorphic_code_cache();
     Marking::GreyToBlack(Marking::MarkBitFrom(poly_cache));
     MemoryChunk::IncrementLiveBytesFromGC(poly_cache->address(),
                                           PolymorphicCodeCache::kSize);
   }
 
-  Object* context = heap_->native_contexts_list();
+  Object* context = heap_->global_contexts_list();
   while (!context->IsUndefined()) {
     // GC can happen when the context is not fully initialized,
     // so the cache can be undefined.
     HeapObject* cache = HeapObject::cast(
         Context::cast(context)->get(Context::NORMALIZED_MAP_CACHE_INDEX));
     if (!cache->IsUndefined()) {
       MarkBit mark_bit = Marking::MarkBitFrom(cache);
       if (Marking::IsGrey(mark_bit)) {
         Marking::GreyToBlack(mark_bit);
         MemoryChunk::IncrementLiveBytesFromGC(cache->address(), cache->Size());
@@ skipping 89 matching lines @@
     start = OS::TimeCurrentMillis();
   }
 
   if (state_ == SWEEPING) {
     if (heap_->AdvanceSweepers(static_cast<int>(bytes_to_process))) {
       bytes_scanned_ = 0;
       StartMarking(PREVENT_COMPACTION);
     }
   } else if (state_ == MARKING) {
     Map* filler_map = heap_->one_pointer_filler_map();
-    Map* native_context_map = heap_->native_context_map();
+    Map* global_context_map = heap_->global_context_map();
     while (!marking_deque_.IsEmpty() && bytes_to_process > 0) {
       HeapObject* obj = marking_deque_.Pop();
 
       // Explicitly skip one word fillers. Incremental markbit patterns are
       // correct only for objects that occupy at least two words.
       Map* map = obj->map();
       if (map == filler_map) continue;
 
       int size = obj->SizeFromMap(map);
       bytes_to_process -= size;
       MarkBit map_mark_bit = Marking::MarkBitFrom(map);
       if (Marking::IsWhite(map_mark_bit)) {
         WhiteToGreyAndPush(map, map_mark_bit);
       }
 
       // TODO(gc) switch to static visitor instead of normal visitor.
-      if (map == native_context_map) {
-        // Native contexts have weak fields.
+      if (map == global_context_map) {
+        // Global contexts have weak fields.
         Context* ctx = Context::cast(obj);
 
         // We will mark cache black with a separate pass
         // when we finish marking.
         MarkObjectGreyDoNotEnqueue(ctx->normalized_map_cache());
 
-        IncrementalMarkingMarkingVisitor::VisitNativeContext(map, ctx);
+        IncrementalMarkingMarkingVisitor::VisitGlobalContext(map, ctx);
       } else if (map->instance_type() == MAP_TYPE) {
         Map* map = Map::cast(obj);
         heap_->ClearCacheOnMap(map);
 
         // When map collection is enabled we have to mark through map's
         // transitions and back pointers in a special way to make these links
         // weak.  Only maps for subclasses of JSReceiver can have transitions.
         STATIC_ASSERT(LAST_TYPE == LAST_JS_RECEIVER_TYPE);
         if (FLAG_collect_maps &&
             map->instance_type() >= FIRST_JS_RECEIVER_TYPE) {
@@ skipping 109 matching lines @@
   allocation_marking_factor_ = kInitialAllocationMarkingFactor;
   bytes_scanned_ = 0;
 }
 
 
 int64_t IncrementalMarking::SpaceLeftInOldSpace() {
   return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
 }
 
 } }  // namespace v8::internal