Revert to code state of 3.13.1 plus r12350

src/type-info.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 42 matching lines @@
   } else if (value->IsString()) {
     info = TypeInfo::String();
   } else {
     info = TypeInfo::Unknown();
   }
   return info;
 }
 
 
 TypeFeedbackOracle::TypeFeedbackOracle(Handle<Code> code,
-                                       Handle<Context> native_context,
+                                       Handle<Context> global_context,
                                        Isolate* isolate,
                                        Zone* zone) {
-  native_context_ = native_context;
+  global_context_ = global_context;
   isolate_ = isolate;
   zone_ = zone;
   BuildDictionary(code);
   ASSERT(reinterpret_cast<Address>(*dictionary_.location()) != kHandleZapValue);
 }
 
 
 static uint32_t IdToKey(TypeFeedbackId ast_id) {
   return static_cast<uint32_t>(ast_id.ToInt());
 }
@@ skipping 21 matching lines @@
 bool TypeFeedbackOracle::LoadIsMonomorphicNormal(Property* expr) {
   Handle<Object> map_or_code = GetInfo(expr->PropertyFeedbackId());
   if (map_or_code->IsMap()) return true;
   if (map_or_code->IsCode()) {
     Handle<Code> code = Handle<Code>::cast(map_or_code);
     bool preliminary_checks = code->is_keyed_load_stub() &&
         code->ic_state() == MONOMORPHIC &&
         Code::ExtractTypeFromFlags(code->flags()) == Code::NORMAL;
     if (!preliminary_checks) return false;
     Map* map = code->FindFirstMap();
-    return map != NULL && !CanRetainOtherContext(map, *native_context_);
+    return map != NULL && !CanRetainOtherContext(map, *global_context_);
   }
   return false;
 }
 
 
 bool TypeFeedbackOracle::LoadIsMegamorphicWithTypeInfo(Property* expr) {
   Handle<Object> map_or_code = GetInfo(expr->PropertyFeedbackId());
   if (map_or_code->IsCode()) {
     Handle<Code> code = Handle<Code>::cast(map_or_code);
     Builtins* builtins = isolate_->builtins();
@@ skipping 13 matching lines @@
     bool allow_growth =
         Code::GetKeyedAccessGrowMode(code->extra_ic_state()) ==
         ALLOW_JSARRAY_GROWTH;
     bool preliminary_checks =
         code->is_keyed_store_stub() &&
         !allow_growth &&
         code->ic_state() == MONOMORPHIC &&
         Code::ExtractTypeFromFlags(code->flags()) == Code::NORMAL;
     if (!preliminary_checks) return false;
     Map* map = code->FindFirstMap();
-    return map != NULL && !CanRetainOtherContext(map, *native_context_);
+    return map != NULL && !CanRetainOtherContext(map, *global_context_);
   }
   return false;
 }
 
 
 bool TypeFeedbackOracle::StoreIsMegamorphicWithTypeInfo(TypeFeedbackId ast_id) {
   Handle<Object> map_or_code = GetInfo(ast_id);
   if (map_or_code->IsCode()) {
     Handle<Code> code = Handle<Code>::cast(map_or_code);
     Builtins* builtins = isolate_->builtins();
@@ skipping 36 matching lines @@
 }
 
 
 Handle<Map> TypeFeedbackOracle::LoadMonomorphicReceiverType(Property* expr) {
   ASSERT(LoadIsMonomorphicNormal(expr));
   Handle<Object> map_or_code = GetInfo(expr->PropertyFeedbackId());
   if (map_or_code->IsCode()) {
     Handle<Code> code = Handle<Code>::cast(map_or_code);
     Map* first_map = code->FindFirstMap();
     ASSERT(first_map != NULL);
-    return CanRetainOtherContext(first_map, *native_context_)
+    return CanRetainOtherContext(first_map, *global_context_)
         ? Handle<Map>::null()
         : Handle<Map>(first_map);
   }
   return Handle<Map>::cast(map_or_code);
 }
 
 
 Handle<Map> TypeFeedbackOracle::StoreMonomorphicReceiverType(
     TypeFeedbackId ast_id) {
   ASSERT(StoreIsMonomorphicNormal(ast_id));
   Handle<Object> map_or_code = GetInfo(ast_id);
   if (map_or_code->IsCode()) {
     Handle<Code> code = Handle<Code>::cast(map_or_code);
     Map* first_map = code->FindFirstMap();
     ASSERT(first_map != NULL);
-    return CanRetainOtherContext(first_map, *native_context_)
+    return CanRetainOtherContext(first_map, *global_context_)
         ? Handle<Map>::null()
         : Handle<Map>(first_map);
   }
   return Handle<Map>::cast(map_or_code);
 }
 
 
 void TypeFeedbackOracle::LoadReceiverTypes(Property* expr,
                                            Handle<String> name,
                                            SmallMapList* types) {
@@ skipping 42 matching lines @@
 
 
 Handle<JSObject> TypeFeedbackOracle::GetPrototypeForPrimitiveCheck(
     CheckType check) {
   JSFunction* function = NULL;
   switch (check) {
     case RECEIVER_MAP_CHECK:
       UNREACHABLE();
       break;
     case STRING_CHECK:
-      function = native_context_->string_function();
+      function = global_context_->string_function();
       break;
     case NUMBER_CHECK:
-      function = native_context_->number_function();
+      function = global_context_->number_function();
       break;
     case BOOLEAN_CHECK:
-      function = native_context_->boolean_function();
+      function = global_context_->boolean_function();
       break;
   }
   ASSERT(function != NULL);
   return Handle<JSObject>(JSObject::cast(function->instance_prototype()));
 }
 
 
 Handle<JSFunction> TypeFeedbackOracle::GetCallTarget(Call* expr) {
   return Handle<JSFunction>::cast(GetInfo(expr->CallFeedbackId()));
 }
@@ skipping 61 matching lines @@
   Handle<Object> object = GetInfo(expr->CompareOperationFeedbackId());
   if (!object->IsCode()) return Handle<Map>::null();
   Handle<Code> code = Handle<Code>::cast(object);
   if (!code->is_compare_ic_stub()) return Handle<Map>::null();
   CompareIC::State state = static_cast<CompareIC::State>(code->compare_state());
   if (state != CompareIC::KNOWN_OBJECTS) {
     return Handle<Map>::null();
   }
   Map* first_map = code->FindFirstMap();
   ASSERT(first_map != NULL);
-  return CanRetainOtherContext(first_map, *native_context_)
+  return CanRetainOtherContext(first_map, *global_context_)
       ? Handle<Map>::null()
       : Handle<Map>(first_map);
 }
 
 
 TypeInfo TypeFeedbackOracle::UnaryType(UnaryOperation* expr) {
   Handle<Object> object = GetInfo(expr->UnaryOperationFeedbackId());
   TypeInfo unknown = TypeInfo::Unknown();
   if (!object->IsCode()) return unknown;
   Handle<Code> code = Handle<Code>::cast(object);
@@ skipping 138 matching lines @@
     ASSERT(Handle<Code>::cast(object)->ic_state() == MEGAMORPHIC);
   } else if (object->IsMap()) {
     types->Add(Handle<Map>::cast(object), zone());
   } else if (FLAG_collect_megamorphic_maps_from_stub_cache &&
       Handle<Code>::cast(object)->ic_state() == MEGAMORPHIC) {
     types->Reserve(4, zone());
     ASSERT(object->IsCode());
     isolate_->stub_cache()->CollectMatchingMaps(types,
                                                 *name,
                                                 flags,
-                                                native_context_,
+                                                global_context_,
                                                 zone());
   }
 }
 
 
-// Check if a map originates from a given native context. We use this
+// Check if a map originates from a given global context. We use this
 // information to filter out maps from different context to avoid
 // retaining objects from different tabs in Chrome via optimized code.
 bool TypeFeedbackOracle::CanRetainOtherContext(Map* map,
-                                               Context* native_context) {
+                                               Context* global_context) {
   Object* constructor = NULL;
   while (!map->prototype()->IsNull()) {
     constructor = map->constructor();
     if (!constructor->IsNull()) {
       // If the constructor is not null or a JSFunction, we have to
-      // conservatively assume that it may retain a native context.
+      // conservatively assume that it may retain a global context.
       if (!constructor->IsJSFunction()) return true;
       // Check if the constructor directly references a foreign context.
       if (CanRetainOtherContext(JSFunction::cast(constructor),
-                                native_context)) {
+                                global_context)) {
         return true;
       }
     }
     map = HeapObject::cast(map->prototype())->map();
   }
   constructor = map->constructor();
   if (constructor->IsNull()) return false;
   JSFunction* function = JSFunction::cast(constructor);
-  return CanRetainOtherContext(function, native_context);
+  return CanRetainOtherContext(function, global_context);
 }
 
 
 bool TypeFeedbackOracle::CanRetainOtherContext(JSFunction* function,
-                                               Context* native_context) {
-  return function->context()->global_object() != native_context->global_object()
-      && function->context()->global_object() != native_context->builtins();
+                                               Context* global_context) {
+  return function->context()->global() != global_context->global()
+      && function->context()->global() != global_context->builtins();
 }
 
 
 static void AddMapIfMissing(Handle<Map> map, SmallMapList* list,
                             Zone* zone) {
   for (int i = 0; i < list->length(); ++i) {
     if (list->at(i).is_identical_to(map)) return;
   }
   list->Add(map, zone);
 }
 
 
 void TypeFeedbackOracle::CollectKeyedReceiverTypes(TypeFeedbackId ast_id,
                                                    SmallMapList* types) {
   Handle<Object> object = GetInfo(ast_id);
   if (!object->IsCode()) return;
   Handle<Code> code = Handle<Code>::cast(object);
   if (code->kind() == Code::KEYED_LOAD_IC ||
       code->kind() == Code::KEYED_STORE_IC) {
     AssertNoAllocation no_allocation;
     int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
     for (RelocIterator it(*code, mask); !it.done(); it.next()) {
       RelocInfo* info = it.rinfo();
       Object* object = info->target_object();
       if (object->IsMap()) {
         Map* map = Map::cast(object);
-        if (!CanRetainOtherContext(map, *native_context_)) {
+        if (!CanRetainOtherContext(map, *global_context_)) {
           AddMapIfMissing(Handle<Map>(map), types, zone());
         }
       }
     }
   }
 }
 
 
 byte TypeFeedbackOracle::ToBooleanTypes(TypeFeedbackId ast_id) {
   Handle<Object> object = GetInfo(ast_id);
@@ skipping 66 matching lines @@
       case Code::KEYED_CALL_IC:
         if (target->ic_state() == MONOMORPHIC) {
           if (target->kind() == Code::CALL_IC &&
               target->check_type() != RECEIVER_MAP_CHECK) {
             SetInfo(ast_id, Smi::FromInt(target->check_type()));
           } else {
             Object* map = target->FindFirstMap();
             if (map == NULL) {
               SetInfo(ast_id, static_cast<Object*>(target));
             } else if (!CanRetainOtherContext(Map::cast(map),
-                                              *native_context_)) {
+                                              *global_context_)) {
               SetInfo(ast_id, map);
             }
           }
         } else {
           SetInfo(ast_id, target);
         }
         break;
 
       case Code::KEYED_LOAD_IC:
       case Code::KEYED_STORE_IC:
@@ skipping 21 matching lines @@
   Object* raw_info = code->type_feedback_info();
   if (!raw_info->IsTypeFeedbackInfo()) return;
   Handle<TypeFeedbackCells> cache(
       TypeFeedbackInfo::cast(raw_info)->type_feedback_cells());
   for (int i = 0; i < cache->CellCount(); i++) {
     TypeFeedbackId ast_id = cache->AstId(i);
     Object* value = cache->Cell(i)->value();
     if (value->IsSmi() ||
         (value->IsJSFunction() &&
          !CanRetainOtherContext(JSFunction::cast(value),
-                                *native_context_))) {
+                                *global_context_))) {
       SetInfo(ast_id, value);
     }
   }
 }
 
 
 void TypeFeedbackOracle::SetInfo(TypeFeedbackId ast_id, Object* target) {
   ASSERT(dictionary_->FindEntry(IdToKey(ast_id)) ==
          UnseededNumberDictionary::kNotFound);
   MaybeObject* maybe_result = dictionary_->AtNumberPut(IdToKey(ast_id), target);
   USE(maybe_result);
 #ifdef DEBUG
   Object* result = NULL;
   // Dictionary has been allocated with sufficient size for all elements.
   ASSERT(maybe_result->ToObject(&result));
   ASSERT(*dictionary_ == result);
 #endif
 }
 
 } }  // namespace v8::internal