Treat the builtins object like other global objects (with...

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 401 matching lines @@
         // 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);
         break;
       }
       case NORMAL: {
         if (!object->IsJSObject()) return;
-        if (object->IsJSGlobalObject()) {
+        if (object->IsGlobalObject()) {
           // 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<JSGlobalObject> global = Handle<JSGlobalObject>::cast(object);
+          Handle<GlobalObject> global = Handle<GlobalObject>::cast(object);
           if (lookup->holder() != *global) return;
           JSGlobalPropertyCell* cell =
               JSGlobalPropertyCell::cast(global->GetPropertyCell(lookup));
           if (cell->value()->IsJSFunction()) {
             JSFunction* function = JSFunction::cast(cell->value());
             code = StubCache::ComputeCallGlobal(argc, in_loop, *name, *global,
                                                 cell, function);
           }
         } else {
           // There is only one shared stub for calling normalized
@@ skipping 180 matching lines @@
                                            lookup->GetFieldIndex());
         break;
       }
       case CONSTANT_FUNCTION: {
         Object* constant = lookup->GetConstantFunction();
         code = StubCache::ComputeLoadConstant(*name, *receiver,
                                               lookup->holder(), constant);
         break;
       }
       case NORMAL: {
-        if (object->IsJSGlobalObject()) {
+        if (object->IsGlobalObject()) {
           // 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<JSGlobalObject> global = Handle<JSGlobalObject>::cast(object);
+          Handle<GlobalObject> global = Handle<GlobalObject>::cast(object);
           if (lookup->holder() != *global) return;
           JSGlobalPropertyCell* cell =
               JSGlobalPropertyCell::cast(global->GetPropertyCell(lookup));
           code = StubCache::ComputeLoadGlobal(*name, *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.
@@ skipping 327 matching lines @@
     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);
       break;
     }
     case NORMAL: {
-      if (!receiver->IsJSGlobalObject()) {
+      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<JSGlobalObject> global = Handle<JSGlobalObject>::cast(receiver);
+      Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver);
       JSGlobalPropertyCell* cell =
           JSGlobalPropertyCell::cast(global->GetPropertyCell(lookup));
       code = StubCache::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);
@@ skipping 323 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal