- Begin removing [static] qualifier from methods in StubCache....

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 487 matching lines @@
     // Set the target to the pre monomorphic stub to delay
     // setting the monomorphic state.
     code = StubCache::ComputeCallPreMonomorphic(argc, in_loop);
   } else if (state == MONOMORPHIC) {
     code = StubCache::ComputeCallMegamorphic(argc, in_loop);
   } else {
     // Compute monomorphic stub.
     switch (lookup->type()) {
       case FIELD: {
         int index = lookup->GetFieldIndex();
-        code = StubCache::ComputeCallField(argc, in_loop, *name, *object,
-                                           lookup->holder(), index);
+        code = Isolate::Current()->stub_cache()->ComputeCallField(
+            argc,
+            in_loop,
+            *name,
+            *object,
+            lookup->holder(),
+            index);
         break;
       }
       case CONSTANT_FUNCTION: {
         // Get the constant function and compute the code stub for this
         // call; used for rewriting to monomorphic state and making sure
         // that the code stub is in the stub cache.
         JSFunction* function = lookup->GetConstantFunction();
-        code = StubCache::ComputeCallConstant(argc, in_loop, *name, *object,
-                                              lookup->holder(), function);
+        code = Isolate::Current()->stub_cache()->ComputeCallConstant(
+            argc,
+            in_loop,
+            *name,
+            *object,
+            lookup->holder(),
+            function);
         break;
       }
       case NORMAL: {
         if (!object->IsJSObject()) return;
         Handle<JSObject> receiver = Handle<JSObject>::cast(object);
 
         if (lookup->holder()->IsGlobalObject()) {
           GlobalObject* global = GlobalObject::cast(lookup->holder());
           JSGlobalPropertyCell* cell =
               JSGlobalPropertyCell::cast(global->GetPropertyCell(lookup));
           if (!cell->value()->IsJSFunction()) return;
           JSFunction* function = JSFunction::cast(cell->value());
-          code = StubCache::ComputeCallGlobal(argc,
-                                              in_loop,
-                                              *name,
-                                              *receiver,
-                                              global,
-                                              cell,
-                                              function);
+          code = Isolate::Current()->stub_cache()->ComputeCallGlobal(argc,
+                                                                     in_loop,
+                                                                     *name,
+                                                                     *receiver,
+                                                                     global,
+                                                                     cell,
+                                                                     function);
         } else {
           // There is only one shared stub for calling normalized
           // properties. It does not traverse the prototype chain, so the
           // property must be found in the receiver for the stub to be
           // applicable.
           if (lookup->holder() != *receiver) return;
-          code = StubCache::ComputeCallNormal(argc, in_loop, *name, *receiver);
+          code = Isolate::Current()->stub_cache()->ComputeCallNormal(argc,
+                                                                     in_loop,
+                                                                     *name,
+                                                                     *receiver);
         }
         break;
       }
       case INTERCEPTOR: {
         ASSERT(HasInterceptorGetter(lookup->holder()));
-        code = StubCache::ComputeCallInterceptor(argc, *name, *object,
-                                                 lookup->holder());
+        code = Isolate::Current()->stub_cache()->ComputeCallInterceptor(
+            argc,
+            *name,
+            *object,
+            lookup->holder());
         break;
       }
       default:
         return;
     }
   }
 
   // If we're unable to compute the stub (not enough memory left), we
   // simply avoid updating the caches.
   if (code == NULL || code->IsFailure()) return;
@@ skipping 153 matching lines @@
 
   // Compute the code stub for this load.
   Object* code = NULL;
   if (state == UNINITIALIZED) {
     // This is the first time we execute this inline cache.
     // Set the target to the pre monomorphic stub to delay
     // setting the monomorphic state.
     code = pre_monomorphic_stub();
   } else if (!lookup->IsProperty()) {
     // Nonexistent property. The result is undefined.
-    code = StubCache::ComputeLoadNonexistent(*name, *receiver);
+    code = Isolate::Current()->stub_cache()->ComputeLoadNonexistent(*name,
+                                                                    *receiver);
   } else {
     // Compute monomorphic stub.
     switch (lookup->type()) {
       case FIELD: {
-        code = StubCache::ComputeLoadField(*name, *receiver,
-                                           lookup->holder(),
-                                           lookup->GetFieldIndex());
+        code = Isolate::Current()->stub_cache()->ComputeLoadField(
+            *name,
+            *receiver,
+            lookup->holder(),
+            lookup->GetFieldIndex());
         break;
       }
       case CONSTANT_FUNCTION: {
         Object* constant = lookup->GetConstantFunction();
-        code = StubCache::ComputeLoadConstant(*name, *receiver,
-                                              lookup->holder(), constant);
+        code = Isolate::Current()->stub_cache()->ComputeLoadConstant(
+            *name,
+            *receiver,
+            lookup->holder(),
+            constant);
         break;
       }
       case NORMAL: {
         if (lookup->holder()->IsGlobalObject()) {
           GlobalObject* global = GlobalObject::cast(lookup->holder());
           JSGlobalPropertyCell* cell =
               JSGlobalPropertyCell::cast(global->GetPropertyCell(lookup));
-          code = StubCache::ComputeLoadGlobal(*name,
-                                              *receiver,
-                                              global,
-                                              cell,
-                                              lookup->IsDontDelete());
+          code = Isolate::Current()->stub_cache()->ComputeLoadGlobal(
+              *name,
+              *receiver,
+              global,
+              cell,
+              lookup->IsDontDelete());
         } else {
           // There is only one shared stub for loading normalized
           // properties. It does not traverse the prototype chain, so the
           // property must be found in the receiver for the stub to be
           // applicable.
           if (lookup->holder() != *receiver) return;
-          code = StubCache::ComputeLoadNormal(*name, *receiver);
+          code = Isolate::Current()->stub_cache()->ComputeLoadNormal(*name,
+                                                                     *receiver);
         }
         break;
       }
       case CALLBACKS: {
         if (!lookup->GetCallbackObject()->IsAccessorInfo()) return;
         AccessorInfo* callback =
             AccessorInfo::cast(lookup->GetCallbackObject());
         if (v8::ToCData<Address>(callback->getter()) == 0) return;
-        code = StubCache::ComputeLoadCallback(*name, *receiver,
-                                              lookup->holder(), callback);
+        code = Isolate::Current()->stub_cache()->ComputeLoadCallback(
+            *name,
+            *receiver,
+            lookup->holder(),
+            callback);
         break;
       }
       case INTERCEPTOR: {
         ASSERT(HasInterceptorGetter(lookup->holder()));
-        code = StubCache::ComputeLoadInterceptor(*name, *receiver,
-                                                 lookup->holder());
+        code = Isolate::Current()->stub_cache()->ComputeLoadInterceptor(
+            *name,
+            *receiver,
+            lookup->holder());
         break;
       }
       default:
         return;
     }
   }
 
   // If we're unable to compute the stub (not enough memory left), we
   // simply avoid updating the caches.
   if (code == NULL || code->IsFailure()) return;
@@ skipping 22 matching lines @@
     // of its properties; throw a TypeError in that case.
     if (object->IsUndefined() || object->IsNull()) {
       return TypeError("non_object_property_load", object, name);
     }
 
     if (FLAG_use_ic) {
       // Use specialized code for getting the length of strings.
       if (object->IsString() && name->Equals(HEAP->length_symbol())) {
         Handle<String> string = Handle<String>::cast(object);
         Object* code = NULL;
-        code = StubCache::ComputeKeyedLoadStringLength(*name, *string);
+        code = Isolate::Current()->stub_cache()->ComputeKeyedLoadStringLength(
+            *name,
+            *string);
         if (code->IsFailure()) return code;
         set_target(Code::cast(code));
 #ifdef DEBUG
         TraceIC("KeyedLoadIC", name, state, target());
 #endif  // DEBUG
         return Smi::FromInt(string->length());
       }
 
       // Use specialized code for getting the length of arrays.
       if (object->IsJSArray() && name->Equals(HEAP->length_symbol())) {
         Handle<JSArray> array = Handle<JSArray>::cast(object);
-        Object* code = StubCache::ComputeKeyedLoadArrayLength(*name, *array);
+        Object* code =
+            Isolate::Current()->stub_cache()->ComputeKeyedLoadArrayLength(
+                *name,
+                *array);
         if (code->IsFailure()) return code;
         set_target(Code::cast(code));
 #ifdef DEBUG
         TraceIC("KeyedLoadIC", name, state, target());
 #endif  // DEBUG
         return JSArray::cast(*object)->length();
       }
 
       // Use specialized code for getting prototype of functions.
       if (object->IsJSFunction() && name->Equals(HEAP->prototype_symbol()) &&
         JSFunction::cast(*object)->should_have_prototype()) {
         Handle<JSFunction> function = Handle<JSFunction>::cast(object);
         Object* code =
-            StubCache::ComputeKeyedLoadFunctionPrototype(*name, *function);
+            Isolate::Current()->stub_cache()->ComputeKeyedLoadFunctionPrototype(
+                *name,
+                *function);
         if (code->IsFailure()) return code;
         set_target(Code::cast(code));
 #ifdef DEBUG
         TraceIC("KeyedLoadIC", name, state, target());
 #endif  // DEBUG
         return Accessors::FunctionGetPrototype(*object, 0);
       }
     }
 
     // Check if the name is trivially convertible to an index and get
@@ skipping 83 matching lines @@
 
   if (state == UNINITIALIZED) {
     // This is the first time we execute this inline cache.
     // Set the target to the pre monomorphic stub to delay
     // setting the monomorphic state.
     code = pre_monomorphic_stub();
   } else {
     // Compute a monomorphic stub.
     switch (lookup->type()) {
       case FIELD: {
-        code = StubCache::ComputeKeyedLoadField(*name, *receiver,
-                                                lookup->holder(),
-                                                lookup->GetFieldIndex());
+        code = Isolate::Current()->stub_cache()->ComputeKeyedLoadField(
+            *name,
+            *receiver,
+            lookup->holder(),
+            lookup->GetFieldIndex());
         break;
       }
       case CONSTANT_FUNCTION: {
         Object* constant = lookup->GetConstantFunction();
-        code = StubCache::ComputeKeyedLoadConstant(*name, *receiver,
-                                                   lookup->holder(), constant);
+        code = Isolate::Current()->stub_cache()->ComputeKeyedLoadConstant(
+            *name,
+            *receiver,
+            lookup->holder(),
+            constant);
         break;
       }
       case CALLBACKS: {
         if (!lookup->GetCallbackObject()->IsAccessorInfo()) return;
         AccessorInfo* callback =
             AccessorInfo::cast(lookup->GetCallbackObject());
         if (v8::ToCData<Address>(callback->getter()) == 0) return;
-        code = StubCache::ComputeKeyedLoadCallback(*name, *receiver,
-                                                   lookup->holder(), callback);
+        code = Isolate::Current()->stub_cache()->ComputeKeyedLoadCallback(
+            *name,
+            *receiver,
+            lookup->holder(),
+            callback);
         break;
       }
       case INTERCEPTOR: {
         ASSERT(HasInterceptorGetter(lookup->holder()));
-        code = StubCache::ComputeKeyedLoadInterceptor(*name, *receiver,
-                                                      lookup->holder());
+        code = Isolate::Current()->stub_cache()->ComputeKeyedLoadInterceptor(
+            *name,
+            *receiver,
+            lookup->holder());
         break;
       }
       default: {
         // Always rewrite to the generic case so that we do not
         // repeatedly try to rewrite.
         code = generic_stub();
         break;
       }
     }
   }
@@ skipping 112 matching lines @@
   // where there is extra room in the object, we leave the IC in its
   // current state.
   PropertyType type = lookup->type();
 
   // Compute the code stub for this store; used for rewriting to
   // monomorphic state and making sure that the code stub is in the
   // stub cache.
   Object* code = NULL;
   switch (type) {
     case FIELD: {
-      code = StubCache::ComputeStoreField(*name, *receiver,
-                                          lookup->GetFieldIndex());
+      code = Isolate::Current()->stub_cache()->ComputeStoreField(
+          *name,
+          *receiver,
+          lookup->GetFieldIndex());
       break;
     }
     case MAP_TRANSITION: {
       if (lookup->GetAttributes() != NONE) return;
       HandleScope scope;
       ASSERT(type == MAP_TRANSITION);
       Handle<Map> transition(lookup->GetTransitionMap());
       int index = transition->PropertyIndexFor(*name);
-      code = StubCache::ComputeStoreField(*name, *receiver, index, *transition);
+      code = Isolate::Current()->stub_cache()->ComputeStoreField(*name,
+                                                                 *receiver,
+                                                                 index,
+                                                                 *transition);
       break;
     }
     case NORMAL: {
       if (!receiver->IsGlobalObject()) {
         return;
       }
       // The stub generated for the global object picks the value directly
       // from the property cell. So the property must be directly on the
       // global object.
       Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver);
       JSGlobalPropertyCell* cell =
           JSGlobalPropertyCell::cast(global->GetPropertyCell(lookup));
-      code = StubCache::ComputeStoreGlobal(*name, *global, cell);
+      code = Isolate::Current()->stub_cache()->ComputeStoreGlobal(*name,
+                                                                  *global,
+                                                                  cell);
       break;
     }
     case CALLBACKS: {
       if (!lookup->GetCallbackObject()->IsAccessorInfo()) return;
       AccessorInfo* callback = AccessorInfo::cast(lookup->GetCallbackObject());
       if (v8::ToCData<Address>(callback->setter()) == 0) return;
-      code = StubCache::ComputeStoreCallback(*name, *receiver, callback);
+      code = Isolate::Current()->stub_cache()->ComputeStoreCallback(*name,
+                                                                    *receiver,
+                                                                    callback);
       break;
     }
     case INTERCEPTOR: {
       ASSERT(!receiver->GetNamedInterceptor()->setter()->IsUndefined());
-      code = StubCache::ComputeStoreInterceptor(*name, *receiver);
+      code = Isolate::Current()->stub_cache()->ComputeStoreInterceptor(
+          *name,
+          *receiver);
       break;
     }
     default:
       return;
   }
 
   // If we're unable to compute the stub (not enough memory left), we
   // simply avoid updating the caches.
   if (code == NULL || code->IsFailure()) return;
 
@@ skipping 91 matching lines @@
   // current state.
   PropertyType type = lookup->type();
 
   // Compute the code stub for this store; used for rewriting to
   // monomorphic state and making sure that the code stub is in the
   // stub cache.
   Object* code = NULL;
 
   switch (type) {
     case FIELD: {
-      code = StubCache::ComputeKeyedStoreField(*name, *receiver,
-                                               lookup->GetFieldIndex());
+      code = Isolate::Current()->stub_cache()->ComputeKeyedStoreField(
+          *name,
+          *receiver,
+          lookup->GetFieldIndex());
       break;
     }
     case MAP_TRANSITION: {
       if (lookup->GetAttributes() == NONE) {
         HandleScope scope;
         ASSERT(type == MAP_TRANSITION);
         Handle<Map> transition(lookup->GetTransitionMap());
         int index = transition->PropertyIndexFor(*name);
-        code = StubCache::ComputeKeyedStoreField(*name, *receiver,
-                                                 index, *transition);
+        code = Isolate::Current()->stub_cache()->ComputeKeyedStoreField(
+            *name,
+            *receiver,
+            index,
+            *transition);
         break;
       }
       // fall through.
     }
     default: {
       // Always rewrite to the generic case so that we do not
       // repeatedly try to rewrite.
       code = generic_stub();
       break;
     }
@@ skipping 239 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal