Revert to code state of 3.13.1 plus r12350

src/objects-inl.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 556 matching lines @@
 }
 
 
 bool Object::IsContext() {
   if (Object::IsHeapObject()) {
     Map* map = HeapObject::cast(this)->map();
     Heap* heap = map->GetHeap();
     return (map == heap->function_context_map() ||
             map == heap->catch_context_map() ||
             map == heap->with_context_map() ||
-            map == heap->native_context_map() ||
+            map == heap->global_context_map() ||
             map == heap->block_context_map() ||
             map == heap->module_context_map());
   }
   return false;
 }
 
 
-bool Object::IsNativeContext() {
+bool Object::IsGlobalContext() {
   return Object::IsHeapObject() &&
       HeapObject::cast(this)->map() ==
-      HeapObject::cast(this)->GetHeap()->native_context_map();
+      HeapObject::cast(this)->GetHeap()->global_context_map();
 }
 
 
 bool Object::IsModuleContext() {
   return Object::IsHeapObject() &&
       HeapObject::cast(this)->map() ==
       HeapObject::cast(this)->GetHeap()->module_context_map();
 }
 
 
@@ skipping 733 matching lines @@
   return this;
 }
 
 
 MaybeObject* JSObject::GetElementsTransitionMap(Isolate* isolate,
                                                 ElementsKind to_kind) {
   Map* current_map = map();
   ElementsKind from_kind = current_map->elements_kind();
   if (from_kind == to_kind) return current_map;
 
-  Context* native_context = isolate->context()->native_context();
-  Object* maybe_array_maps = native_context->js_array_maps();
+  Context* global_context = isolate->context()->global_context();
+  Object* maybe_array_maps = global_context->js_array_maps();
   if (maybe_array_maps->IsFixedArray()) {
     FixedArray* array_maps = FixedArray::cast(maybe_array_maps);
     if (array_maps->get(from_kind) == current_map) {
       Object* maybe_transitioned_map = array_maps->get(to_kind);
       if (maybe_transitioned_map->IsMap()) {
         return Map::cast(maybe_transitioned_map);
       }
     }
   }
 
@@ skipping 2308 matching lines @@
 
 
 ACCESSORS(Map, code_cache, Object, kCodeCacheOffset)
 ACCESSORS(Map, constructor, Object, kConstructorOffset)
 
 ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)
 ACCESSORS(JSFunction, literals_or_bindings, FixedArray, kLiteralsOffset)
 ACCESSORS(JSFunction, next_function_link, Object, kNextFunctionLinkOffset)
 
 ACCESSORS(GlobalObject, builtins, JSBuiltinsObject, kBuiltinsOffset)
-ACCESSORS(GlobalObject, native_context, Context, kNativeContextOffset)
+ACCESSORS(GlobalObject, global_context, Context, kGlobalContextOffset)
 ACCESSORS(GlobalObject, global_receiver, JSObject, kGlobalReceiverOffset)
 
-ACCESSORS(JSGlobalProxy, native_context, Object, kNativeContextOffset)
+ACCESSORS(JSGlobalProxy, context, Object, kContextOffset)
 
 ACCESSORS(AccessorInfo, getter, Object, kGetterOffset)
 ACCESSORS(AccessorInfo, setter, Object, kSetterOffset)
 ACCESSORS(AccessorInfo, data, Object, kDataOffset)
 ACCESSORS(AccessorInfo, name, Object, kNameOffset)
 ACCESSORS_TO_SMI(AccessorInfo, flag, kFlagOffset)
 ACCESSORS(AccessorInfo, expected_receiver_type, Object,
           kExpectedReceiverTypeOffset)
 
 ACCESSORS(AccessorPair, getter, Object, kGetterOffset)
@@ skipping 463 matching lines @@
   if (tries >= 16 && (((tries - 1) & tries) == 0)) {
     set_optimization_disabled(false);
     set_opt_count(0);
     set_deopt_count(0);
     code()->set_optimizable(true);
   }
 }
 
 
 bool JSFunction::IsBuiltin() {
-  return context()->global_object()->IsJSBuiltinsObject();
+  return context()->global()->IsJSBuiltinsObject();
 }
 
 
 bool JSFunction::NeedsArgumentsAdaption() {
   return shared()->formal_parameter_count() !=
       SharedFunctionInfo::kDontAdaptArgumentsSentinel;
 }
 
 
 bool JSFunction::IsOptimized() {
@@ skipping 47 matching lines @@
 
 void JSFunction::ReplaceCode(Code* code) {
   bool was_optimized = IsOptimized();
   bool is_optimized = code->kind() == Code::OPTIMIZED_FUNCTION;
 
   set_code(code);
 
   // Add/remove the function from the list of optimized functions for this
   // context based on the state change.
   if (!was_optimized && is_optimized) {
-    context()->native_context()->AddOptimizedFunction(this);
+    context()->global_context()->AddOptimizedFunction(this);
   }
   if (was_optimized && !is_optimized) {
-    context()->native_context()->RemoveOptimizedFunction(this);
+    context()->global_context()->RemoveOptimizedFunction(this);
   }
 }
 
 
 Context* JSFunction::context() {
   return Context::cast(READ_FIELD(this, kContextOffset));
 }
 
 
 Object* JSFunction::unchecked_context() {
@@ skipping 22 matching lines @@
 }
 
 
 void JSFunction::set_initial_map(Map* value) {
   set_prototype_or_initial_map(value);
 }
 
 
 MaybeObject* JSFunction::set_initial_map_and_cache_transitions(
     Map* initial_map) {
-  Context* native_context = context()->native_context();
+  Context* global_context = context()->global_context();
   Object* array_function =
-      native_context->get(Context::ARRAY_FUNCTION_INDEX);
+      global_context->get(Context::ARRAY_FUNCTION_INDEX);
   if (array_function->IsJSFunction() &&
       this == JSFunction::cast(array_function)) {
-    // Replace all of the cached initial array maps in the native context with
+    // Replace all of the cached initial array maps in the global context with
     // the appropriate transitioned elements kind maps.
     Heap* heap = GetHeap();
     MaybeObject* maybe_maps =
         heap->AllocateFixedArrayWithHoles(kElementsKindCount);
     FixedArray* maps;
     if (!maybe_maps->To(&maps)) return maybe_maps;
 
     Map* current_map = initial_map;
     ElementsKind kind = current_map->elements_kind();
     ASSERT(kind == GetInitialFastElementsKind());
     maps->set(kind, current_map);
     for (int i = GetSequenceIndexFromFastElementsKind(kind) + 1;
          i < kFastElementsKindCount; ++i) {
       Map* new_map;
       ElementsKind next_kind = GetFastElementsKindFromSequenceIndex(i);
       MaybeObject* maybe_new_map =
           current_map->CopyAsElementsKind(next_kind, INSERT_TRANSITION);
       if (!maybe_new_map->To(&new_map)) return maybe_new_map;
       maps->set(next_kind, new_map);
       current_map = new_map;
     }
-    native_context->set_js_array_maps(maps);
+    global_context->set_js_array_maps(maps);
   }
   set_initial_map(initial_map);
   return this;
 }
 
 
 bool JSFunction::has_initial_map() {
   return prototype_or_initial_map()->IsMap();
 }
 
@@ skipping 1001 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_