Avoid GC when compiling CallIC stubs....

src/ic.cc

 // Copyright 2006-2009 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 483 matching lines @@
 
     // Try to find a suitable function delegate for the object at hand.
     result = TryCallAsFunction(result);
     if (result->IsJSFunction()) return result;
 
     // Otherwise, it will fail in the lookup step.
   }
 
   // Lookup the property in the object.
   LookupResult lookup;
-  LookupForRead(*object, *name, &lookup);
+  {
+    AssertNoGC nogc;  // GC could invalidate the pointers held in lookup.
 
-  if (!lookup.IsProperty()) {
-    // If the object does not have the requested property, check which
-    // exception we need to throw.
-    if (IsContextual(object)) {
-      return ReferenceError("not_defined", name);
+    LookupForRead(*object, *name, &lookup);
+
+    if (!lookup.IsProperty()) {
+      // If the object does not have the requested property, check which
+      // exception we need to throw.
+      if (IsContextual(object)) {
+        return ReferenceError("not_defined", name);
+      }
+      return TypeError("undefined_method", object, name);
     }
-    return TypeError("undefined_method", object, name);
-  }
 
-  // Lookup is valid: Update inline cache and stub cache.
-  if (FLAG_use_ic) {
-    UpdateCaches(&lookup, state, object, name);
+    // Lookup is valid: Update inline cache and stub cache.
+    if (FLAG_use_ic) {
+      UpdateCaches(&lookup, state, object, name);
+    }
   }
 
   // Get the property.
   PropertyAttributes attr;
   Object* result = object->GetProperty(*object, &lookup, *name, &attr);
   if (result->IsFailure()) return result;
   if (lookup.type() == INTERCEPTOR) {
     // If the object does not have the requested property, check which
     // exception we need to throw.
     if (attr == ABSENT) {
@@ skipping 252 matching lines @@
     }
   }
 
   // Check if the name is trivially convertible to an index and get
   // the element if so.
   uint32_t index;
   if (name->AsArrayIndex(&index)) return object->GetElement(index);
 
   // Named lookup in the object.
   LookupResult lookup;
-  LookupForRead(*object, *name, &lookup);
+  {
+    AssertNoGC nogc;  // GC could invalidate the pointers held in lookup.
 
-  // If we did not find a property, check if we need to throw an exception.
-  if (!lookup.IsProperty()) {
-    if (FLAG_strict || IsContextual(object)) {
-      return ReferenceError("not_defined", name);
+    LookupForRead(*object, *name, &lookup);
+
+    // If we did not find a property, check if we need to throw an exception.
+    if (!lookup.IsProperty()) {
+      if (FLAG_strict || IsContextual(object)) {
+        return ReferenceError("not_defined", name);
+      }
+      LOG(SuspectReadEvent(*name, *object));
     }
-    LOG(SuspectReadEvent(*name, *object));
-  }
 
-  bool can_be_inlined =
-      FLAG_use_ic &&
-      state == PREMONOMORPHIC &&
-      lookup.IsProperty() &&
-      lookup.IsCacheable() &&
-      lookup.holder() == *object &&
-      lookup.type() == FIELD &&
-      !object->IsAccessCheckNeeded();
+    bool can_be_inlined =
+        FLAG_use_ic &&
+        state == PREMONOMORPHIC &&
+        lookup.IsProperty() &&
+        lookup.IsCacheable() &&
+        lookup.holder() == *object &&
+        lookup.type() == FIELD &&
+        !object->IsAccessCheckNeeded();
 
-  if (can_be_inlined) {
-    Map* map = lookup.holder()->map();
-    // Property's index in the properties array.  If negative we have
-    // an inobject property.
-    int index = lookup.GetFieldIndex() - map->inobject_properties();
-    if (index < 0) {
-      // Index is an offset from the end of the object.
-      int offset = map->instance_size() + (index * kPointerSize);
-      if (PatchInlinedLoad(address(), map, offset)) {
-        set_target(megamorphic_stub());
-#ifdef DEBUG
-        if (FLAG_trace_ic) {
-          PrintF("[LoadIC : inline patch %s]\n", *name->ToCString());
+    if (can_be_inlined) {
+      Map* map = lookup.holder()->map();
+      // Property's index in the properties array.  If negative we have
+      // an inobject property.
+      int index = lookup.GetFieldIndex() - map->inobject_properties();
+      if (index < 0) {
+        // Index is an offset from the end of the object.
+        int offset = map->instance_size() + (index * kPointerSize);
+        if (PatchInlinedLoad(address(), map, offset)) {
+          set_target(megamorphic_stub());
+  #ifdef DEBUG
+          if (FLAG_trace_ic) {
+            PrintF("[LoadIC : inline patch %s]\n", *name->ToCString());
+          }
+  #endif
+          return lookup.holder()->FastPropertyAt(lookup.GetFieldIndex());
+  #ifdef DEBUG
+        } else {
+          if (FLAG_trace_ic) {
+            PrintF("[LoadIC : no inline patch %s (patching failed)]\n",
+                   *name->ToCString());
+          }
         }
-#endif
-        return lookup.holder()->FastPropertyAt(lookup.GetFieldIndex());
-#ifdef DEBUG
       } else {
         if (FLAG_trace_ic) {
-          PrintF("[LoadIC : no inline patch %s (patching failed)]\n",
+          PrintF("[LoadIC : no inline patch %s (not inobject)]\n",
                  *name->ToCString());
         }
       }
     } else {
-      if (FLAG_trace_ic) {
-        PrintF("[LoadIC : no inline patch %s (not inobject)]\n",
-               *name->ToCString());
+      if (FLAG_use_ic && state == PREMONOMORPHIC) {
+        if (FLAG_trace_ic) {
+          PrintF("[LoadIC : no inline patch %s (not inlinable)]\n",
+                 *name->ToCString());
+  #endif
+        }
       }
     }
-  } else {
-    if (FLAG_use_ic && state == PREMONOMORPHIC) {
-      if (FLAG_trace_ic) {
-        PrintF("[LoadIC : no inline patch %s (not inlinable)]\n",
-               *name->ToCString());
-#endif
-      }
+
+    // Update inline cache and stub cache.
+    if (FLAG_use_ic) {
+      UpdateCaches(&lookup, state, object, name);
     }
   }
 
-  // Update inline cache and stub cache.
-  if (FLAG_use_ic) {
-    UpdateCaches(&lookup, state, object, name);
-  }
-
   PropertyAttributes attr;
   if (lookup.IsProperty() && lookup.type() == INTERCEPTOR) {
     // Get the property.
     Object* result = object->GetProperty(*object, &lookup, *name, &attr);
     if (result->IsFailure()) return result;
     // If the property is not present, check if we need to throw an
     // exception.
     if (attr == ABSENT && IsContextual(object)) {
       return ReferenceError("not_defined", name);
     }
@@ skipping 167 matching lines @@
     uint32_t index = 0;
     if (name->AsArrayIndex(&index)) {
       HandleScope scope;
       // Rewrite to the generic keyed load stub.
       if (FLAG_use_ic) set_target(generic_stub());
       return Runtime::GetElementOrCharAt(object, index);
     }
 
     // Named lookup.
     LookupResult lookup;
-    LookupForRead(*object, *name, &lookup);
+    {
+      AssertNoGC nogc;  // GC could invalidate the pointers held in lookup.
 
-    // If we did not find a property, check if we need to throw an exception.
-    if (!lookup.IsProperty()) {
-      if (FLAG_strict || IsContextual(object)) {
-        return ReferenceError("not_defined", name);
+      LookupForRead(*object, *name, &lookup);
+
+      // If we did not find a property, check if we need to throw an exception.
+      if (!lookup.IsProperty()) {
+        if (FLAG_strict || IsContextual(object)) {
+          return ReferenceError("not_defined", name);
+        }
+      }
+
+      if (FLAG_use_ic) {
+        UpdateCaches(&lookup, state, object, name);
       }
     }
 
-    if (FLAG_use_ic) {
-      UpdateCaches(&lookup, state, object, name);
-    }
-
     PropertyAttributes attr;
     if (lookup.IsProperty() && lookup.type() == INTERCEPTOR) {
       // Get the property.
       Object* result = object->GetProperty(*object, &lookup, *name, &attr);
       if (result->IsFailure()) return result;
       // If the property is not present, check if we need to throw an
       // exception.
       if (attr == ABSENT && IsContextual(object)) {
         return ReferenceError("not_defined", name);
       }
@@ skipping 175 matching lines @@
 #ifdef DEBUG
     if (FLAG_trace_ic) PrintF("[StoreIC : +#length /array]\n");
 #endif
     Code* target = Builtins::builtin(Builtins::StoreIC_ArrayLength);
     set_target(target);
     return receiver->SetProperty(*name, *value, NONE);
   }
 
   // Lookup the property locally in the receiver.
   if (FLAG_use_ic && !receiver->IsJSGlobalProxy()) {
+    AssertNoGC nogc;  // GC could invalidate the pointers held in lookup.
+
     LookupResult lookup;
 
     if (LookupForWrite(*receiver, *name, &lookup)) {
       bool can_be_inlined =
           state == UNINITIALIZED &&
           lookup.IsProperty() &&
           lookup.holder() == *receiver &&
           lookup.type() == FIELD &&
           !receiver->IsAccessCheckNeeded();
 
@@ skipping 153 matching lines @@
 
     // Check if the given name is an array index.
     uint32_t index;
     if (name->AsArrayIndex(&index)) {
       HandleScope scope;
       Handle<Object> result = SetElement(receiver, index, value);
       if (result.is_null()) return Failure::Exception();
       return *value;
     }
 
-    // Lookup the property locally in the receiver.
-    LookupResult lookup;
-    receiver->LocalLookup(*name, &lookup);
+    {
+      AssertNoGC nogc;  // GC could invalidate the pointers held in lookup.
 
-    // Update inline cache and stub cache.
-    if (FLAG_use_ic) {
-      UpdateCaches(&lookup, state, receiver, name, value);
+      // Lookup the property locally in the receiver.
+      LookupResult lookup;
+      receiver->LocalLookup(*name, &lookup);
+
+      // Update inline cache and stub cache.
+      if (FLAG_use_ic) {
+        UpdateCaches(&lookup, state, receiver, name, value);
+      }
     }
 
     // Set the property.
     return receiver->SetProperty(*name, *value, NONE);
   }
 
   // Do not use ICs for objects that require access checks (including
   // the global object).
   bool use_ic = FLAG_use_ic && !object->IsAccessCheckNeeded();
   ASSERT(!(use_ic && object->IsJSGlobalProxy()));
@@ skipping 380 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal