Inline mathematical constants

src/objects.cc

 // Copyright 2013 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 3973 matching lines @@
                                              PropertyAttributes attributes) {
   if (lookup->GetAttributes() == attributes) {
     if (value->IsUninitialized()) return;
     SetPropertyToField(lookup, name, value);
   } else {
     ConvertAndSetLocalProperty(lookup, name, value, attributes);
   }
 }
 
 
+static void CheckGlobalReassignmentDependency(Handle<JSObject> object,
+                                              Handle<Name> key) {
+  if (object->IsJSGlobalObject() && key->IsString()) {
+    Isolate* isolate = object->GetIsolate();
+    Handle<JSGlobalObject> global = Handle<JSGlobalObject>::cast(object);
+    Handle<String> keyString = Handle<String>::cast(key);
+    // Deoptimize code that assumes the global Math object
+    // is not reassigned
+    if (keyString->IsOneByteEqualTo(STATIC_ASCII_VECTOR("Math"))) {
+      global->map()->dependent_code()->DeoptimizeDependentCodeGroup(isolate,
+                                            DependentCode::kMathConstantGroup);
+    }
+  }
+}
+
+
 Handle<Object> JSObject::SetPropertyForResult(Handle<JSObject> object,
                                               LookupResult* lookup,
                                               Handle<Name> name,
                                               Handle<Object> value,
                                               PropertyAttributes attributes,
                                               StrictMode strict_mode,
                                               StoreFromKeyed store_mode) {
   Isolate* isolate = object->GetIsolate();
 
   // Make sure that the top context does not change when doing callbacks or
@@ skipping 17 matching lines @@
   }
 
   if (object->IsJSGlobalProxy()) {
     Handle<Object> proto(object->GetPrototype(), isolate);
     if (proto->IsNull()) return value;
     ASSERT(proto->IsJSGlobalObject());
     return SetPropertyForResult(Handle<JSObject>::cast(proto),
         lookup, name, value, attributes, strict_mode, store_mode);
   }
 
+  CheckGlobalReassignmentDependency(object, name);
+
   ASSERT(!lookup->IsFound() || lookup->holder() == *object ||
          lookup->holder()->map()->is_hidden_prototype());
 
   if (!lookup->IsProperty() && !object->IsJSContextExtensionObject()) {
     bool done = false;
     Handle<Object> result_object = SetPropertyViaPrototypes(
         object, name, value, attributes, strict_mode, &done);
     if (done) return result_object;
   }
 
@@ skipping 116 matching lines @@
   }
 
   if (object->IsJSGlobalProxy()) {
     Handle<Object> proto(object->GetPrototype(), isolate);
     if (proto->IsNull()) return value;
     ASSERT(proto->IsJSGlobalObject());
     return SetLocalPropertyIgnoreAttributes(Handle<JSObject>::cast(proto),
         name, value, attributes, value_type, mode, extensibility_check);
   }
 
+  CheckGlobalReassignmentDependency(object, name);
+
   if (lookup.IsFound() &&
       (lookup.type() == INTERCEPTOR || lookup.type() == CALLBACKS)) {
     object->LocalLookupRealNamedProperty(*name, &lookup);
   }
 
   // Check for accessor in prototype chain removed here in clone.
   if (!lookup.IsFound()) {
     object->map()->LookupTransition(*object, *name, &lookup);
     TransitionFlag flag = lookup.IsFound()
         ? OMIT_TRANSITION : INSERT_TRANSITION;
@@ skipping 706 matching lines @@
 
   ASSERT(key->IsUniqueName());
   if (object->IsJSGlobalProxy()) {
     // For a proxy, use the prototype as target object.
     Handle<Object> proxy_parent(object->GetPrototype(), isolate);
     // If the proxy is detached, return undefined.
     if (proxy_parent->IsNull()) return isolate->factory()->undefined_value();
     ASSERT(proxy_parent->IsJSGlobalObject());
     return SetHiddenProperty(Handle<JSObject>::cast(proxy_parent), key, value);
   }
+
+  CheckGlobalReassignmentDependency(object, key);
+
   ASSERT(!object->IsJSGlobalProxy());
 
   Handle<Object> inline_value(object->GetHiddenPropertiesHashTable(), isolate);
 
   // If there is no backing store yet, store the identity hash inline.
   if (value->IsSmi() &&
       *key == *isolate->factory()->identity_hash_string() &&
       (inline_value->IsUndefined() || inline_value->IsSmi())) {
     return JSObject::SetHiddenPropertiesHashTable(object, value);
   }
@@ skipping 19 matching lines @@
   Isolate* isolate = object->GetIsolate();
   ASSERT(key->IsUniqueName());
 
   if (object->IsJSGlobalProxy()) {
     Handle<Object> proto(object->GetPrototype(), isolate);
     if (proto->IsNull()) return;
     ASSERT(proto->IsJSGlobalObject());
     return DeleteHiddenProperty(Handle<JSObject>::cast(proto), key);
   }
 
+  CheckGlobalReassignmentDependency(object, key);
+
   Object* inline_value = object->GetHiddenPropertiesHashTable();
 
   // We never delete (inline-stored) identity hashes.
   ASSERT(*key != *isolate->factory()->identity_hash_string());
   if (inline_value->IsUndefined() || inline_value->IsSmi()) return;
 
   Handle<ObjectHashTable> hashtable(ObjectHashTable::cast(inline_value));
   ObjectHashTable::Put(hashtable, key, isolate->factory()->the_hole_value());
 }
 
@@ skipping 275 matching lines @@
   }
 
   if (object->IsJSGlobalProxy()) {
     Object* proto = object->GetPrototype();
     if (proto->IsNull()) return isolate->factory()->false_value();
     ASSERT(proto->IsJSGlobalObject());
     return JSGlobalObject::DeleteProperty(
         handle(JSGlobalObject::cast(proto)), name, mode);
   }
 
+  CheckGlobalReassignmentDependency(object, name);
+
   uint32_t index = 0;
   if (name->AsArrayIndex(&index)) {
     return DeleteElement(object, index, mode);
   }
 
   LookupResult lookup(isolate);
   object->LocalLookup(*name, &lookup, true);
   if (!lookup.IsFound()) return isolate->factory()->true_value();
   // Ignore attributes if forcing a deletion.
   if (lookup.IsDontDelete() && mode != FORCE_DELETION) {
@@ skipping 1084 matching lines @@
     ASSERT(proto->IsJSGlobalObject());
     DefineAccessor(Handle<JSObject>::cast(proto),
                    name,
                    getter,
                    setter,
                    attributes,
                    access_control);
     return;
   }
 
+  CheckGlobalReassignmentDependency(object, name);
+
   // Make sure that the top context does not change when doing callbacks or
   // interceptor calls.
   AssertNoContextChange ncc(isolate);
 
   // Try to flatten before operating on the string.
   if (name->IsString()) String::cast(*name)->TryFlatten();
 
   if (!JSObject::CanSetCallback(object, name)) return;
 
   uint32_t index = 0;
@@ skipping 168 matching lines @@
     return factory->undefined_value();
   }
 
   if (object->IsJSGlobalProxy()) {
     Handle<Object> proto(object->GetPrototype(), isolate);
     if (proto->IsNull()) return object;
     ASSERT(proto->IsJSGlobalObject());
     return SetAccessor(Handle<JSObject>::cast(proto), info);
   }
 
+  CheckGlobalReassignmentDependency(object, name);
+
   // Make sure that the top context does not change when doing callbacks or
   // interceptor calls.
   AssertNoContextChange ncc(isolate);
 
   // Try to flatten before operating on the string.
   if (name->IsString()) FlattenString(Handle<String>::cast(name));
 
   if (!JSObject::CanSetCallback(object, name)) {
     return factory->undefined_value();
   }
@@ skipping 9934 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal