/deps/v8/src/ic.cc - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/ic.cc

     void IC::TraceIC(const char* type,
                      Handle<Object> name,
                      State old_state,
                      Code* new_target) {
                      Handle<Object> name) {
       if (FLAG_trace_ic) {
         Object* undef = new_target->GetHeap()->undefined_value();
         State new_state = StateFrom(new_target, undef, undef);
         PrintF("[%s in ", type);
         Isolate* isolate = new_target->GetIsolate();
         StackFrameIterator it(isolate);
         Code* new_target = raw_target();
         State new_state = new_target->ic_state();
         PrintF("[%s%s in ", new_target->is_keyed_stub() ? "Keyed" : "", type);
         StackFrameIterator it(isolate());
         while (it.frame()->fp() != this->fp()) it.Advance();
         StackFrame* raw_frame = it.frame();
         if (raw_frame->is_internal()) {
           Code* apply_builtin = isolate->builtins()->builtin(
           Code* apply_builtin = isolate()->builtins()->builtin(
               Builtins::kFunctionApply);
           if (raw_frame->unchecked_code() == apply_builtin) {
             PrintF("apply from ");
-...
             raw_frame = it.frame();
+          }
+        }
         JavaScriptFrame::PrintTop(isolate, stdout, false, true);
         Code::ExtraICState state = new_target->extra_ic_state();
         JavaScriptFrame::PrintTop(isolate(), stdout, false, true);
         Code::ExtraICState extra_state = new_target->extra_ic_state();
         const char* modifier =
             GetTransitionMarkModifier(Code::GetKeyedAccessStoreMode(state));
             GetTransitionMarkModifier(Code::GetKeyedAccessStoreMode(extra_state));
         PrintF(" (%c->%c%s)",
                TransitionMarkFromState(old_state),
                TransitionMarkFromState(state()),
                TransitionMarkFromState(new_state),
                modifier);
         name->Print();
-...
     #define TRACE_GENERIC_IC(isolate, type, reason)
     #endif  // DEBUG
     #define TRACE_IC(type, name, old_state, new_target)             \
       ASSERT((TraceIC(type, name, old_state, new_target), true))
     #define TRACE_IC(type, name)             \
       ASSERT((TraceIC(type, name), true))
     IC::IC(FrameDepth depth, Isolate* isolate) : isolate_(isolate) {
     IC::IC(FrameDepth depth, Isolate* isolate)
         : isolate_(isolate),
           target_set_(false) {
       // To improve the performance of the (much used) IC code, we unfold a few
       // levels of the stack frame iteration code. This yields a ~35% speedup when
       // running DeltaBlue and a ~25% speedup of gbemu with the '--nouse-ic' flag.
-...
     #endif
       fp_ = fp;
       pc_address_ = StackFrame::ResolveReturnAddressLocation(pc_address);
       target_ = handle(raw_target(), isolate);
       state_ = target_->ic_state();
+    }
-...
     #endif
     static bool TryRemoveInvalidPrototypeDependentStub(Code* target,
                                                        Object* receiver,
                                                        Object* name) {
       if (target->is_keyed_load_stub() ||
           target->is_keyed_call_stub() ||
           target->is_keyed_store_stub()) {
     static bool HasInterceptorGetter(JSObject* object) {
       return !object->GetNamedInterceptor()->getter()->IsUndefined();
+    }
     static bool HasInterceptorSetter(JSObject* object) {
       return !object->GetNamedInterceptor()->setter()->IsUndefined();
+    }
     static void LookupForRead(Handle<Object> object,
                               Handle<String> name,
                               LookupResult* lookup) {
       // Skip all the objects with named interceptors, but
       // without actual getter.
       while (true) {
         object->Lookup(*name, lookup);
         // Besides normal conditions (property not found or it's not
         // an interceptor), bail out if lookup is not cacheable: we won't
         // be able to IC it anyway and regular lookup should work fine.
         if (!lookup->IsInterceptor() || !lookup->IsCacheable()) {
           return;
+        }
         Handle<JSObject> holder(lookup->holder(), lookup->isolate());
         if (HasInterceptorGetter(*holder)) {
           return;
+        }
         holder->LocalLookupRealNamedProperty(*name, lookup);
         if (lookup->IsFound()) {
           ASSERT(!lookup->IsInterceptor());
           return;
+        }
         Handle<Object> proto(holder->GetPrototype(), lookup->isolate());
         if (proto->IsNull()) {
           ASSERT(!lookup->IsFound());
           return;
+        }
         object = proto;
+      }
+    }
     bool CallIC::TryUpdateExtraICState(LookupResult* lookup,
                                        Handle<Object> object) {
       if (!lookup->IsConstantFunction()) return false;
       JSFunction* function = lookup->GetConstantFunction();
       if (!function->shared()->HasBuiltinFunctionId()) return false;
       // Fetch the arguments passed to the called function.
       const int argc = target()->arguments_count();
       Address entry = isolate()->c_entry_fp(isolate()->thread_local_top());
       Address fp = Memory::Address_at(entry + ExitFrameConstants::kCallerFPOffset);
       Arguments args(argc + 1,
                      &Memory::Object_at(fp +
                                         StandardFrameConstants::kCallerSPOffset +
                                         argc * kPointerSize));
       switch (function->shared()->builtin_function_id()) {
         case kStringCharCodeAt:
         case kStringCharAt:
           if (object->IsString()) {
             String* string = String::cast(*object);
             // Check there's the right string value or wrapper in the receiver slot.
             ASSERT(string == args[0] || string == JSValue::cast(args[0])->value());
             // If we're in the default (fastest) state and the index is
             // out of bounds, update the state to record this fact.
             if (StringStubState::decode(extra_ic_state()) == DEFAULT_STRING_STUB &&
                 argc >= 1 && args[1]->IsNumber()) {
               double index = DoubleToInteger(args.number_at(1));
               if (index < 0 || index >= string->length()) {
                 extra_ic_state_ =
                     StringStubState::update(extra_ic_state(),
                                             STRING_INDEX_OUT_OF_BOUNDS);
                 return true;
+              }
+            }
+          }
           break;
         default:
           return false;
+      }
       return false;
+    }
     bool IC::TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver,
                                                     Handle<String> name) {
       DisallowHeapAllocation no_gc;
       if (target()->is_call_stub()) {
         LookupResult lookup(isolate());
         LookupForRead(receiver, name, &lookup);
         if (static_cast<CallIC*>(this)->TryUpdateExtraICState(&lookup, receiver)) {
           return true;
+        }
+      }
       if (target()->is_keyed_stub()) {
         // Determine whether the failure is due to a name failure.
         if (!name->IsName()) return false;
         Name* stub_name = target->FindFirstName();
         if (Name::cast(name) != stub_name) return false;
         Name* stub_name = target()->FindFirstName();
         if (*name != stub_name) return false;
+      }
       InlineCacheHolderFlag cache_holder =
           Code::ExtractCacheHolderFromFlags(target->flags());
           Code::ExtractCacheHolderFromFlags(target()->flags());
       Isolate* isolate = target->GetIsolate();
       if (cache_holder == OWN_MAP && !receiver->IsJSObject()) {
         // The stub was generated for JSObject but called for non-JSObject.
         // IC::GetCodeCacheHolder is not applicable.
         return false;
       } else if (cache_holder == PROTOTYPE_MAP &&
                  receiver->GetPrototype(isolate)->IsNull()) {
         // IC::GetCodeCacheHolder is not applicable.
         return false;
       switch (cache_holder) {
         case OWN_MAP:
           // The stub was generated for JSObject but called for non-JSObject.
           // IC::GetCodeCacheHolder is not applicable.
           if (!receiver->IsJSObject()) return false;
           break;
         case PROTOTYPE_MAP:
           // IC::GetCodeCacheHolder is not applicable.
           if (receiver->GetPrototype(isolate())->IsNull()) return false;
           break;
+      }
       Map* map = IC::GetCodeCacheHolder(isolate, receiver, cache_holder)->map();
       Handle<Map> map(
           IC::GetCodeCacheHolder(isolate(), *receiver, cache_holder)->map());
       // Decide whether the inline cache failed because of changes to the
       // receiver itself or changes to one of its prototypes.
-...
       // the receiver map's code cache.  Therefore, if the current target
       // is in the receiver map's code cache, the inline cache failed due
       // to prototype check failure.
       int index = map->IndexInCodeCache(name, target);
       int index = map->IndexInCodeCache(*name, *target());
       if (index >= 0) {
         map->RemoveFromCodeCache(String::cast(name), target, index);
         // For loads and stores, handlers are stored in addition to the ICs on the
         // map. Remove those, too.
         if ((target->is_load_stub() || target->is_keyed_load_stub() ||
              target->is_store_stub() || target->is_keyed_store_stub()) &&
             target->type() != Code::NORMAL) {
           Code* handler = target->FindFirstCode();
           index = map->IndexInCodeCache(name, handler);
           if (index >= 0) {
             map->RemoveFromCodeCache(String::cast(name), handler, index);
+          }
+        }
         map->RemoveFromCodeCache(*name, *target(), index);
         // Handlers are stored in addition to the ICs on the map. Remove those, too.
         TryRemoveInvalidHandlers(map, name);
         return true;
+      }
-...
       // If the IC is shared between multiple receivers (slow dictionary mode), then
       // the map cannot be deprecated and the stub invalidated.
       if (cache_holder == OWN_MAP) {
         Map* old_map = target->FindFirstMap();
         if (old_map == map) return true;
         Map* old_map = target()->FindFirstMap();
         if (old_map == *map) return true;
         if (old_map != NULL) {
           if (old_map->is_deprecated()) return true;
           if (IsMoreGeneralElementsKindTransition(old_map->elements_kind(),
-...
+      }
       if (receiver->IsGlobalObject()) {
         if (!name->IsName()) return false;
         Isolate* isolate = target->GetIsolate();
         LookupResult lookup(isolate);
         GlobalObject* global = GlobalObject::cast(receiver);
         global->LocalLookupRealNamedProperty(Name::cast(name), &lookup);
         LookupResult lookup(isolate());
         GlobalObject* global = GlobalObject::cast(*receiver);
         global->LocalLookupRealNamedProperty(*name, &lookup);
         if (!lookup.IsFound()) return false;
         PropertyCell* cell = global->GetPropertyCell(&lookup);
         return cell->type()->IsConstant();
-...
+    }
     IC::State IC::StateFrom(Code* target, Object* receiver, Object* name) {
       IC::State state = target->ic_state();
     void IC::TryRemoveInvalidHandlers(Handle<Map> map, Handle<String> name) {
       CodeHandleList handlers;
       target()->FindHandlers(&handlers);
       for (int i = 0; i < handlers.length(); i++) {
         Handle<Code> handler = handlers.at(i);
         int index = map->IndexInCodeCache(*name, *handler);
         if (index >= 0) {
           map->RemoveFromCodeCache(*name, *handler, index);
           return;
+        }
+      }
+    }
       if (state != MONOMORPHIC || !name->IsString()) return state;
       if (receiver->IsUndefined() || receiver->IsNull()) return state;
     void IC::UpdateState(Handle<Object> receiver, Handle<Object> name) {
       if (!name->IsString()) return;
       if (state() != MONOMORPHIC) {
         if (state() == POLYMORPHIC && receiver->IsHeapObject()) {
           TryRemoveInvalidHandlers(
               handle(Handle<HeapObject>::cast(receiver)->map()),
               Handle<String>::cast(name));
+        }
         return;
+      }
       if (receiver->IsUndefined() || receiver->IsNull()) return;
       Code::Kind kind = target->kind();
       // Remove the target from the code cache if it became invalid
       // because of changes in the prototype chain to avoid hitting it
       // again.
       // Call stubs handle this later to allow extra IC state
       // transitions.
       if (kind != Code::CALL_IC && kind != Code::KEYED_CALL_IC &&
           TryRemoveInvalidPrototypeDependentStub(target, receiver, name)) {
         return MONOMORPHIC_PROTOTYPE_FAILURE;
       if (TryRemoveInvalidPrototypeDependentStub(
               receiver, Handle<String>::cast(name))) {
         return MarkMonomorphicPrototypeFailure();
+      }
       // The builtins object is special.  It only changes when JavaScript
-...
       // an inline cache miss for the builtins object after lazily loading
       // JavaScript builtins, we return uninitialized as the state to
       // force the inline cache back to monomorphic state.
       if (receiver->IsJSBuiltinsObject()) {
         return UNINITIALIZED;
+      }
       return MONOMORPHIC;
       if (receiver->IsJSBuiltinsObject()) state_ = UNINITIALIZED;
+    }
-...
     void CallICBase::Clear(Address address, Code* target) {
       if (target->ic_state() == UNINITIALIZED) return;
       if (IsCleared(target)) return;
       bool contextual = CallICBase::Contextual::decode(target->extra_ic_state());
       Code* code =
           target->GetIsolate()->stub_cache()->FindCallInitialize(
-...
     void KeyedLoadIC::Clear(Isolate* isolate, Address address, Code* target) {
       if (target->ic_state() == UNINITIALIZED) return;
       if (IsCleared(target)) return;
       // Make sure to also clear the map used in inline fast cases.  If we
       // do not clear these maps, cached code can keep objects alive
       // through the embedded maps.
       SetTargetAtAddress(address, *initialize_stub(isolate));
       SetTargetAtAddress(address, *pre_monomorphic_stub(isolate));
+    }
     void LoadIC::Clear(Isolate* isolate, Address address, Code* target) {
       if (target->ic_state() == UNINITIALIZED) return;
       SetTargetAtAddress(address, *initialize_stub(isolate));
       if (IsCleared(target)) return;
       SetTargetAtAddress(address, *pre_monomorphic_stub(isolate));
+    }
     void StoreIC::Clear(Isolate* isolate, Address address, Code* target) {
       if (target->ic_state() == UNINITIALIZED) return;
       if (IsCleared(target)) return;
       SetTargetAtAddress(address,
           (Code::GetStrictMode(target->extra_ic_state()) == kStrictMode)
             ? *initialize_stub_strict(isolate)
             : *initialize_stub(isolate));
           *pre_monomorphic_stub(
               isolate, Code::GetStrictMode(target->extra_ic_state())));
+    }
     void KeyedStoreIC::Clear(Isolate* isolate, Address address, Code* target) {
       if (target->ic_state() == UNINITIALIZED) return;
       if (IsCleared(target)) return;
       SetTargetAtAddress(address,
           (Code::GetStrictMode(target->extra_ic_state()) == kStrictMode)
             ? *initialize_stub_strict(isolate)
             : *initialize_stub(isolate));
           *pre_monomorphic_stub(
               isolate, Code::GetStrictMode(target->extra_ic_state())));
+    }
-...
+    }
     static bool HasInterceptorGetter(JSObject* object) {
       return !object->GetNamedInterceptor()->getter()->IsUndefined();
+    }
     static void LookupForRead(Handle<Object> object,
                               Handle<String> name,
                               LookupResult* lookup) {
       // Skip all the objects with named interceptors, but
       // without actual getter.
       while (true) {
         object->Lookup(*name, lookup);
         // Besides normal conditions (property not found or it's not
         // an interceptor), bail out if lookup is not cacheable: we won't
         // be able to IC it anyway and regular lookup should work fine.
         if (!lookup->IsInterceptor() || !lookup->IsCacheable()) {
           return;
+        }
         Handle<JSObject> holder(lookup->holder(), lookup->isolate());
         if (HasInterceptorGetter(*holder)) {
           return;
+        }
         holder->LocalLookupRealNamedProperty(*name, lookup);
         if (lookup->IsFound()) {
           ASSERT(!lookup->IsInterceptor());
           return;
+        }
         Handle<Object> proto(holder->GetPrototype(), lookup->isolate());
         if (proto->IsNull()) {
           ASSERT(!lookup->IsFound());
           return;
+        }
         object = proto;
+      }
+    }
     Handle<Object> CallICBase::TryCallAsFunction(Handle<Object> object) {
       Handle<Object> delegate = Execution::GetFunctionDelegate(isolate(), object);
-...
+    }
     MaybeObject* CallICBase::LoadFunction(State state,
                                           Code::ExtraICState extra_ic_state,
                                           Handle<Object> object,
     static bool MigrateDeprecated(Handle<Object> object) {
       if (!object->IsJSObject()) return false;
       Handle<JSObject> receiver = Handle<JSObject>::cast(object);
       if (!receiver->map()->is_deprecated()) return false;
       JSObject::MigrateInstance(Handle<JSObject>::cast(object));
       return true;
+    }
     MaybeObject* CallICBase::LoadFunction(Handle<Object> object,
                                           Handle<String> name) {
       if (object->IsJSObject()) {
         Handle<JSObject> receiver = Handle<JSObject>::cast(object);
         if (receiver->map()->is_deprecated()) {
           JSObject::MigrateInstance(receiver);
+        }
+      }
       bool use_ic = MigrateDeprecated(object) ? false : FLAG_use_ic;
       // If the object is undefined or null it's illegal to try to get any
       // of its properties; throw a TypeError in that case.
-...
+      }
       // Lookup is valid: Update inline cache and stub cache.
       if (FLAG_use_ic) {
         UpdateCaches(&lookup, state, extra_ic_state, object, name);
+      }
       if (use_ic) UpdateCaches(&lookup, object, name);
       // Get the property.
       PropertyAttributes attr;
-...
+    }
     bool CallICBase::TryUpdateExtraICState(LookupResult* lookup,
                                            Handle<Object> object,
                                            Code::ExtraICState* extra_ic_state) {
       ASSERT(kind_ == Code::CALL_IC);
       if (!lookup->IsConstantFunction()) return false;
       JSFunction* function = lookup->GetConstantFunction();
       if (!function->shared()->HasBuiltinFunctionId()) return false;
       // Fetch the arguments passed to the called function.
       const int argc = target()->arguments_count();
       Address entry = isolate()->c_entry_fp(isolate()->thread_local_top());
       Address fp = Memory::Address_at(entry + ExitFrameConstants::kCallerFPOffset);
       Arguments args(argc + 1,
                      &Memory::Object_at(fp +
                                         StandardFrameConstants::kCallerSPOffset +
                                         argc * kPointerSize));
       switch (function->shared()->builtin_function_id()) {
         case kStringCharCodeAt:
         case kStringCharAt:
           if (object->IsString()) {
             String* string = String::cast(*object);
             // Check there's the right string value or wrapper in the receiver slot.
             ASSERT(string == args[0] || string == JSValue::cast(args[0])->value());
             // If we're in the default (fastest) state and the index is
             // out of bounds, update the state to record this fact.
             if (StringStubState::decode(*extra_ic_state) == DEFAULT_STRING_STUB &&
                 argc >= 1 && args[1]->IsNumber()) {
               double index = DoubleToInteger(args.number_at(1));
               if (index < 0 || index >= string->length()) {
                 *extra_ic_state =
                     StringStubState::update(*extra_ic_state,
                                             STRING_INDEX_OUT_OF_BOUNDS);
                 return true;
+              }
+            }
+          }
           break;
         default:
           return false;
+      }
       return false;
+    }
     Handle<Code> CallICBase::ComputeMonomorphicStub(LookupResult* lookup,
                                                     State state,
                                                     Code::ExtraICState extra_state,
                                                     Handle<Object> object,
                                                     Handle<String> name) {
       int argc = target()->arguments_count();
-...
         case FIELD: {
           PropertyIndex index = lookup->GetFieldIndex();
           return isolate()->stub_cache()->ComputeCallField(
               argc, kind_, extra_state, name, object, holder, index);
               argc, kind_, extra_ic_state(), name, object, holder, index);
+        }
         case CONSTANT: {
           if (!lookup->IsConstantFunction()) return Handle<Code>::null();
-...
           // that the code stub is in the stub cache.
           Handle<JSFunction> function(lookup->GetConstantFunction(), isolate());
           return isolate()->stub_cache()->ComputeCallConstant(
               argc, kind_, extra_state, name, object, holder, function);
               argc, kind_, extra_ic_state(), name, object, holder, function);
+        }
         case NORMAL: {
           // If we return a null handle, the IC will not be patched.
-...
             if (!cell->value()->IsJSFunction()) return Handle<Code>::null();
             Handle<JSFunction> function(JSFunction::cast(cell->value()));
             return isolate()->stub_cache()->ComputeCallGlobal(
                 argc, kind_, extra_state, name, receiver, global, cell, function);
                 argc, kind_, extra_ic_state(), 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
-...
             // applicable.
             if (!holder.is_identical_to(receiver)) return Handle<Code>::null();
             return isolate()->stub_cache()->ComputeCallNormal(
                 argc, kind_, extra_state);
                 argc, kind_, extra_ic_state());
+          }
           break;
+        }
         case INTERCEPTOR:
           ASSERT(HasInterceptorGetter(*holder));
           return isolate()->stub_cache()->ComputeCallInterceptor(
               argc, kind_, extra_state, name, object, holder);
               argc, kind_, extra_ic_state(), name, object, holder);
         default:
           return Handle<Code>::null();
+      }
+    }
     Handle<Code> CallICBase::megamorphic_stub() {
       return isolate()->stub_cache()->ComputeCallMegamorphic(
           target()->arguments_count(), kind_, extra_ic_state());
+    }
     Handle<Code> CallICBase::pre_monomorphic_stub() {
       return isolate()->stub_cache()->ComputeCallPreMonomorphic(
           target()->arguments_count(), kind_, extra_ic_state());
+    }
     void CallICBase::UpdateCaches(LookupResult* lookup,
                                   State state,
                                   Code::ExtraICState extra_ic_state,
                                   Handle<Object> object,
                                   Handle<String> name) {
       // Bail out if we didn't find a result.
       if (!lookup->IsProperty() || !lookup->IsCacheable()) return;
       // Compute the number of arguments.
       int argc = target()->arguments_count();
       Handle<Code> code;
       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 = isolate()->stub_cache()->ComputeCallPreMonomorphic(
             argc, kind_, extra_ic_state);
       } else if (state == MONOMORPHIC) {
         if (kind_ == Code::CALL_IC &&
             TryUpdateExtraICState(lookup, object, &extra_ic_state)) {
           code = ComputeMonomorphicStub(lookup, state, extra_ic_state,
                                         object, name);
         } else if (TryRemoveInvalidPrototypeDependentStub(target(),
                                                           *object,
                                                           *name)) {
           state = MONOMORPHIC_PROTOTYPE_FAILURE;
           code = ComputeMonomorphicStub(lookup, state, extra_ic_state,
                                         object, name);
         } else {
           code = isolate()->stub_cache()->ComputeCallMegamorphic(
               argc, kind_, extra_ic_state);
+        }
       } else {
         code = ComputeMonomorphicStub(lookup, state, extra_ic_state,
                                       object, name);
+      }
       code = state() == UNINITIALIZED
           ? pre_monomorphic_stub()
           : ComputeMonomorphicStub(lookup, object, name);
       // If there's no appropriate stub we simply avoid updating the caches.
       // TODO(verwaest): Install a slow fallback in this case to avoid not learning,
       // and deopting Crankshaft code.
       if (code.is_null()) return;
       // Patch the call site depending on the state of the cache.
       switch (state) {
         case UNINITIALIZED:
         case MONOMORPHIC_PROTOTYPE_FAILURE:
         case PREMONOMORPHIC:
         case MONOMORPHIC:
           set_target(*code);
           break;
         case MEGAMORPHIC: {
           // Cache code holding map should be consistent with
           // GenerateMonomorphicCacheProbe. It is not the map which holds the stub.
           Handle<JSObject> cache_object = object->IsJSObject()
               ? Handle<JSObject>::cast(object)
               : Handle<JSObject>(JSObject::cast(object->GetPrototype(isolate())),
                                  isolate());
           // Update the stub cache.
           UpdateMegamorphicCache(cache_object->map(), *name, *code);
           break;
+        }
         case DEBUG_STUB:
           break;
         case POLYMORPHIC:
         case GENERIC:
           UNREACHABLE();
           break;
+      }
       Handle<JSObject> cache_object = object->IsJSObject()
           ? Handle<JSObject>::cast(object)
           : Handle<JSObject>(JSObject::cast(object->GetPrototype(isolate())),
                              isolate());
       TRACE_IC(kind_ == Code::CALL_IC ? "CallIC" : "KeyedCallIC",
                name, state, target());
       PatchCache(cache_object, name, code);
       TRACE_IC("CallIC", name);
+    }
     MaybeObject* KeyedCallIC::LoadFunction(State state,
                                            Handle<Object> object,
     MaybeObject* KeyedCallIC::LoadFunction(Handle<Object> object,
                                            Handle<Object> key) {
       if (key->IsInternalizedString()) {
         return CallICBase::LoadFunction(state,
                                         Code::kNoExtraICState,
                                         object,
                                         Handle<String>::cast(key));
+      }
       if (object->IsJSObject()) {
         Handle<JSObject> receiver = Handle<JSObject>::cast(object);
         if (receiver->map()->is_deprecated()) {
           JSObject::MigrateInstance(receiver);
+        }
         return CallICBase::LoadFunction(object, Handle<String>::cast(key));
+      }
       if (object->IsUndefined() || object->IsNull()) {
         return TypeError("non_object_property_call", object, key);
+      }
       bool use_ic = FLAG_use_ic && !object->IsAccessCheckNeeded();
       ASSERT(!(use_ic && object->IsJSGlobalProxy()));
       bool use_ic = MigrateDeprecated(object)
           ? false : FLAG_use_ic && !object->IsAccessCheckNeeded();
       if (use_ic && state != MEGAMORPHIC) {
       if (use_ic && state() != MEGAMORPHIC) {
         ASSERT(!object->IsJSGlobalProxy());
         int argc = target()->arguments_count();
         Handle<Code> stub = isolate()->stub_cache()->ComputeCallMegamorphic(
             argc, Code::KEYED_CALL_IC, Code::kNoExtraICState);
-...
+        }
         ASSERT(!stub.is_null());
         set_target(*stub);
         TRACE_IC("KeyedCallIC", key, state, target());
         TRACE_IC("CallIC", key);
+      }
       Handle<Object> result = GetProperty(isolate(), object, key);
-...
+    }
     MaybeObject* LoadIC::Load(State state,
                               Handle<Object> object,
     MaybeObject* LoadIC::Load(Handle<Object> object,
                               Handle<String> name) {
       // If the object is undefined or null it's illegal to try to get any
       // of its properties; throw a TypeError in that case.
-...
         // string wrapper objects.  The length property of string wrapper
         // objects is read-only and therefore always returns the length of
         // the underlying string value.  See ECMA-262 15.5.5.1.
         if ((object->IsString() || object->IsStringWrapper()) &&
         if (object->IsStringWrapper() &&
             name->Equals(isolate()->heap()->length_string())) {
           Handle<Code> stub;
           if (state == UNINITIALIZED) {
           if (state() == UNINITIALIZED) {
             stub = pre_monomorphic_stub();
           } else if (state == PREMONOMORPHIC) {
             StringLengthStub string_length_stub(kind(), !object->IsString());
             stub = string_length_stub.GetCode(isolate());
           } else if (state == MONOMORPHIC && object->IsStringWrapper()) {
             StringLengthStub string_length_stub(kind(), true);
           } else if (state() == PREMONOMORPHIC || state() == MONOMORPHIC) {
             StringLengthStub string_length_stub(kind());
             stub = string_length_stub.GetCode(isolate());
           } else if (state != MEGAMORPHIC) {
             ASSERT(state != GENERIC);
           } else if (state() != MEGAMORPHIC) {
             ASSERT(state() != GENERIC);
             stub = megamorphic_stub();
+          }
           if (!stub.is_null()) {
             set_target(*stub);
     #ifdef DEBUG
             if (FLAG_trace_ic) PrintF("[LoadIC : +#length /string]\n");
             if (FLAG_trace_ic) PrintF("[LoadIC : +#length /stringwrapper]\n");
     #endif
+          }
           // Get the string if we have a string wrapper object.
           Handle<Object> string = object->IsJSValue()
               ? Handle<Object>(Handle<JSValue>::cast(object)->value(), isolate())
               : object;
           return Smi::FromInt(String::cast(*string)->length());
           String* string = String::cast(JSValue::cast(*object)->value());
           return Smi::FromInt(string->length());
+        }
         // Use specialized code for getting prototype of functions.
-...
             name->Equals(isolate()->heap()->prototype_string()) &&
             Handle<JSFunction>::cast(object)->should_have_prototype()) {
           Handle<Code> stub;
           if (state == UNINITIALIZED) {
           if (state() == UNINITIALIZED) {
             stub = pre_monomorphic_stub();
           } else if (state == PREMONOMORPHIC) {
           } else if (state() == PREMONOMORPHIC) {
             FunctionPrototypeStub function_prototype_stub(kind());
             stub = function_prototype_stub.GetCode(isolate());
           } else if (state != MEGAMORPHIC) {
             ASSERT(state != GENERIC);
           } else if (state() != MEGAMORPHIC) {
             ASSERT(state() != GENERIC);
             stub = megamorphic_stub();
+          }
           if (!stub.is_null()) {
-...
         return Runtime::GetElementOrCharAtOrFail(isolate(), object, index);
+      }
       if (object->IsJSObject()) {
         Handle<JSObject> receiver = Handle<JSObject>::cast(object);
         if (receiver->map()->is_deprecated()) {
           JSObject::MigrateInstance(receiver);
+        }
+      }
       bool use_ic = MigrateDeprecated(object) ? false : FLAG_use_ic;
       // Named lookup in the object.
       LookupResult lookup(isolate());
-...
+      }
       // Update inline cache and stub cache.
       if (FLAG_use_ic) UpdateCaches(&lookup, state, object, name);
       if (use_ic) UpdateCaches(&lookup, object, name);
       PropertyAttributes attr;
       if (lookup.IsInterceptor() || lookup.IsHandler()) {
         // Get the property.
         Handle<Object> result =
             Object::GetProperty(object, object, &lookup, name, &attr);
         RETURN_IF_EMPTY_HANDLE(isolate(), result);
         // If the property is not present, check if we need to throw an
         // exception.
         if (attr == ABSENT && IsUndeclaredGlobal(object)) {
           return ReferenceError("not_defined", name);
+        }
         return *result;
+      }
       // Get the property.
       return Object::GetPropertyOrFail(object, object, &lookup, name, &attr);
       Handle<Object> result =
           Object::GetProperty(object, object, &lookup, name, &attr);
       RETURN_IF_EMPTY_HANDLE(isolate(), result);
       // If the property is not present, check if we need to throw an
       // exception.
       if ((lookup.IsInterceptor() || lookup.IsHandler()) &&
           attr == ABSENT && IsUndeclaredGlobal(object)) {
         return ReferenceError("not_defined", name);
+      }
       return *result;
+    }
-...
+    }
     bool IC::UpdatePolymorphicIC(State state,
                                  Handle<HeapObject> receiver,
     bool IC::UpdatePolymorphicIC(Handle<HeapObject> receiver,
                                  Handle<String> name,
                                  Handle<Code> code,
                                  StrictModeFlag strict_mode) {
       if (code->type() == Code::NORMAL) return false;
       if (target()->ic_state() == MONOMORPHIC &&
           target()->type() == Code::NORMAL) {
         return false;
+      }
                                  Handle<Code> code) {
       if (!code->is_handler()) return false;
       MapHandleList receiver_maps;
       CodeHandleList handlers;
-...
+        }
         if (number_of_valid_maps >= 4) return false;
         if (number_of_maps == 0) return false;
         // Only allow 0 maps in case target() was reset to UNINITIALIZED by the GC.
         // In that case, allow the IC to go back monomorphic.
         if (number_of_maps == 0 && target()->ic_state() != UNINITIALIZED) {
         if (!target()->FindHandlers(&handlers, receiver_maps.length())) {
           return false;
+        }
         target()->FindAllCode(&handlers, receiver_maps.length());
+      }
       number_of_valid_maps++;
-...
         handlers.Add(code);
+      }
       Handle<Code> ic = ComputePolymorphicIC(
           &receiver_maps, &handlers, number_of_valid_maps, name, strict_mode);
       Handle<Code> ic = isolate()->stub_cache()->ComputePolymorphicIC(
           &receiver_maps, &handlers, number_of_valid_maps, name, strict_mode());
       set_target(*ic);
       return true;
+    }
     Handle<Code> LoadIC::ComputePolymorphicIC(MapHandleList* receiver_maps,
                                               CodeHandleList* handlers,
                                               int number_of_valid_maps,
                                               Handle<Name> name,
                                               StrictModeFlag strict_mode) {
       return isolate()->stub_cache()->ComputePolymorphicLoadIC(
           receiver_maps, handlers, number_of_valid_maps, name);
+    }
     Handle<Code> StoreIC::ComputePolymorphicIC(MapHandleList* receiver_maps,
                                                CodeHandleList* handlers,
                                                int number_of_valid_maps,
                                                Handle<Name> name,
                                                StrictModeFlag strict_mode) {
       return isolate()->stub_cache()->ComputePolymorphicStoreIC(
           receiver_maps, handlers, number_of_valid_maps, name, strict_mode);
+    }
     void LoadIC::UpdateMonomorphicIC(Handle<HeapObject> receiver,
                                      Handle<Code> handler,
                                      Handle<String> name,
                                      StrictModeFlag strict_mode) {
       if (handler->is_load_stub()) return set_target(*handler);
       Handle<Code> ic = isolate()->stub_cache()->ComputeMonomorphicLoadIC(
           receiver, handler, name);
       set_target(*ic);
+    }
     void KeyedLoadIC::UpdateMonomorphicIC(Handle<HeapObject> receiver,
                                           Handle<Code> handler,
                                           Handle<String> name,
                                           StrictModeFlag strict_mode) {
       if (handler->is_keyed_load_stub()) return set_target(*handler);
       Handle<Code> ic = isolate()->stub_cache()->ComputeMonomorphicKeyedLoadIC(
           receiver, handler, name);
       set_target(*ic);
+    }
     void StoreIC::UpdateMonomorphicIC(Handle<HeapObject> receiver,
                                       Handle<Code> handler,
                                       Handle<String> name,
                                       StrictModeFlag strict_mode) {
       if (handler->is_store_stub()) return set_target(*handler);
       Handle<Code> ic = isolate()->stub_cache()->ComputeMonomorphicStoreIC(
           receiver, handler, name, strict_mode);
       set_target(*ic);
+    }
     void KeyedStoreIC::UpdateMonomorphicIC(Handle<HeapObject> receiver,
                                            Handle<Code> handler,
                                            Handle<String> name,
                                            StrictModeFlag strict_mode) {
       if (handler->is_keyed_store_stub()) return set_target(*handler);
       Handle<Code> ic = isolate()->stub_cache()->ComputeMonomorphicKeyedStoreIC(
           receiver, handler, name, strict_mode);
     void IC::UpdateMonomorphicIC(Handle<HeapObject> receiver,
                                  Handle<Code> handler,
                                  Handle<String> name) {
       if (!handler->is_handler()) return set_target(*handler);
       Handle<Code> ic = isolate()->stub_cache()->ComputeMonomorphicIC(
           receiver, handler, name, strict_mode());
       set_target(*ic);
+    }
-...
+      {
         DisallowHeapAllocation no_gc;
         target()->FindAllMaps(&receiver_maps);
         target()->FindAllCode(&handlers, receiver_maps.length());
         if (!target()->FindHandlers(&handlers, receiver_maps.length())) return;
+      }
       for (int i = 0; i < receiver_maps.length(); i++) {
         UpdateMegamorphicCache(*receiver_maps.at(i), *name, *handlers.at(i));
-...
+    }
     // Since GC may have been invoked, by the time PatchCache is called, |state| is
     // not necessarily equal to target()->state().
     void IC::PatchCache(State state,
                         StrictModeFlag strict_mode,
                         Handle<HeapObject> receiver,
     void IC::PatchCache(Handle<HeapObject> receiver,
                         Handle<String> name,
                         Handle<Code> code) {
       switch (state) {
       switch (state()) {
         case UNINITIALIZED:
         case PREMONOMORPHIC:
         case MONOMORPHIC_PROTOTYPE_FAILURE:
           UpdateMonomorphicIC(receiver, code, name, strict_mode);
           UpdateMonomorphicIC(receiver, code, name);
           break;
         case MONOMORPHIC:
           // Only move to megamorphic if the target changes.
           if (target() != *code) {
             if (target()->is_load_stub() || target()->is_store_stub()) {
               bool is_same_handler = false;
+              {
                 DisallowHeapAllocation no_allocation;
                 Code* old_handler = target()->FindFirstCode();
                 is_same_handler = old_handler == *code;
+              }
               if (is_same_handler
                   && IsTransitionedMapOfMonomorphicTarget(receiver->map())) {
                 UpdateMonomorphicIC(receiver, code, name, strict_mode);
                 break;
+              }
               if (UpdatePolymorphicIC(state, receiver, name, code, strict_mode)) {
                 break;
+              }
               if (target()->type() != Code::NORMAL) {
                 CopyICToMegamorphicCache(name);
+              }
           // For now, call stubs are allowed to rewrite to the same stub. This
           // happens e.g., when the field does not contain a function.
           ASSERT(target()->is_call_stub() ||
                  target()->is_keyed_call_stub() ||
                  !target().is_identical_to(code));
           if (!target()->is_keyed_stub()) {
             bool is_same_handler = false;
+            {
               DisallowHeapAllocation no_allocation;
               Code* old_handler = target()->FindFirstHandler();
               is_same_handler = old_handler == *code;
+            }
             if (is_same_handler
                 && IsTransitionedMapOfMonomorphicTarget(receiver->map())) {
               UpdateMonomorphicIC(receiver, code, name);
               break;
+            }
             if (UpdatePolymorphicIC(receiver, name, code)) {
               break;
+            }
             UpdateMegamorphicCache(receiver->map(), *name, *code);
             set_target((strict_mode == kStrictMode)
                          ? *megamorphic_stub_strict()
                          : *megamorphic_stub());
             CopyICToMegamorphicCache(name);
+          }
           UpdateMegamorphicCache(receiver->map(), *name, *code);
           set_target(*megamorphic_stub());
           break;
         case MEGAMORPHIC:
           // Update the stub cache.
           UpdateMegamorphicCache(receiver->map(), *name, *code);
           break;
         case POLYMORPHIC:
           if (target()->is_load_stub() || target()->is_store_stub()) {
             if (UpdatePolymorphicIC(state, receiver, name, code, strict_mode)) {
           if (target()->is_keyed_stub()) {
             // When trying to patch a polymorphic keyed stub with anything other
             // than another polymorphic stub, go generic.
             set_target(*generic_stub());
           } else {
             if (UpdatePolymorphicIC(receiver, name, code)) {
               break;
+            }
             CopyICToMegamorphicCache(name);
             UpdateMegamorphicCache(receiver->map(), *name, *code);
             set_target((strict_mode == kStrictMode)
                        ? *megamorphic_stub_strict()
                        : *megamorphic_stub());
           } else {
             // When trying to patch a polymorphic keyed load/store element stub
             // with anything other than another polymorphic stub, go generic.
             set_target((strict_mode == kStrictMode)
                        ? *generic_stub_strict()
                        : *generic_stub());
             set_target(*megamorphic_stub());
+          }
           break;
         case DEBUG_STUB:
-...
+    }
     static void GetReceiverMapsForStub(Handle<Code> stub,
                                        MapHandleList* result) {
       ASSERT(stub->is_inline_cache_stub());
       switch (stub->ic_state()) {
         case MONOMORPHIC: {
           Map* map = stub->FindFirstMap();
           if (map != NULL) {
             result->Add(Handle<Map>(map));
+          }
           break;
+        }
         case POLYMORPHIC: {
           DisallowHeapAllocation no_allocation;
           int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
           for (RelocIterator it(*stub, mask); !it.done(); it.next()) {
             RelocInfo* info = it.rinfo();
             Handle<Object> object(info->target_object(), stub->GetIsolate());
             if (object->IsString()) break;
             ASSERT(object->IsMap());
             AddOneReceiverMapIfMissing(result, Handle<Map>::cast(object));
+          }
           break;
+        }
         case MEGAMORPHIC:
           break;
         case UNINITIALIZED:
         case PREMONOMORPHIC:
         case MONOMORPHIC_PROTOTYPE_FAILURE:
         case GENERIC:
         case DEBUG_STUB:
           UNREACHABLE();
           break;
     Handle<Code> LoadIC::SimpleFieldLoad(int offset,
                                          bool inobject,
                                          Representation representation) {
       if (kind() == Code::LOAD_IC) {
         LoadFieldStub stub(inobject, offset, representation);
         return stub.GetCode(isolate());
       } else {
         KeyedLoadFieldStub stub(inobject, offset, representation);
         return stub.GetCode(isolate());
+      }
+    }
     void LoadIC::UpdateCaches(LookupResult* lookup,
                               State state,
                               Handle<Object> object,
                               Handle<String> name) {
       // TODO(verwaest): It would be nice to support loading fields from smis as
       // well. For now just fail to update the cache.
       if (!object->IsHeapObject()) return;
       Handle<HeapObject> receiver = Handle<HeapObject>::cast(object);
       Handle<Code> code;
       if (state == UNINITIALIZED) {
       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.
-...
       } else if (!lookup->IsCacheable()) {
         // Bail out if the result is not cacheable.
         code = slow_stub();
       } else if (object->IsString() &&
                  name->Equals(isolate()->heap()->length_string())) {
         int length_index = String::kLengthOffset / kPointerSize;
         code = SimpleFieldLoad(length_index);
       } else if (!object->IsJSObject()) {
         // TODO(jkummerow): It would be nice to support non-JSObjects in
         // ComputeLoadHandler, then we wouldn't need to go generic here.
         code = slow_stub();
       } else if (!lookup->IsProperty()) {
         code = kind() == Code::LOAD_IC
             ? isolate()->stub_cache()->ComputeLoadNonexistent(
                   name, Handle<JSObject>::cast(receiver))
             : slow_stub();
       } else {
         code = ComputeLoadHandler(lookup, Handle<JSObject>::cast(receiver), name);
         if (code.is_null()) code = slow_stub();
         code = ComputeHandler(lookup, Handle<JSObject>::cast(receiver), name);
+      }
       PatchCache(state, kNonStrictMode, receiver, name, code);
       TRACE_IC("LoadIC", name, state, target());
       PatchCache(receiver, name, code);
       TRACE_IC("LoadIC", name);
+    }
-...
+    }
     Handle<Code> LoadIC::ComputeLoadHandler(LookupResult* lookup,
                                             Handle<JSObject> receiver,
                                             Handle<String> name) {
       if (!lookup->IsProperty()) {
         // Nonexistent property. The result is undefined.
         return isolate()->stub_cache()->ComputeLoadNonexistent(name, receiver);
     Handle<Code> IC::ComputeHandler(LookupResult* lookup,
                                     Handle<JSObject> receiver,
                                     Handle<String> name,
                                     Handle<Object> value) {
       Handle<Code> code = isolate()->stub_cache()->FindHandler(
           name, receiver, kind());
       if (!code.is_null()) return code;
       code = CompileHandler(lookup, receiver, name, value);
       if (code->is_handler() && code->type() != Code::NORMAL) {
         HeapObject::UpdateMapCodeCache(receiver, name, code);
+      }
       // Compute monomorphic stub.
       return code;
+    }
     Handle<Code> LoadIC::CompileHandler(LookupResult* lookup,
                                         Handle<JSObject> receiver,
                                         Handle<String> name,
                                         Handle<Object> unused) {
       Handle<JSObject> holder(lookup->holder());
       LoadStubCompiler compiler(isolate(), kind());
       switch (lookup->type()) {
         case FIELD:
           return isolate()->stub_cache()->ComputeLoadField(
               name, receiver, holder,
               lookup->GetFieldIndex(), lookup->representation());
         case FIELD: {
           PropertyIndex field = lookup->GetFieldIndex();
           if (receiver.is_identical_to(holder)) {
             return SimpleFieldLoad(field.translate(holder),
                                    field.is_inobject(holder),
                                    lookup->representation());
+          }
           return compiler.CompileLoadField(
               receiver, holder, name, field, lookup->representation());
+        }
         case CONSTANT: {
           Handle<Object> constant(lookup->GetConstant(), isolate());
           // TODO(2803): Don't compute a stub for cons strings because they cannot
           // be embedded into code.
           if (constant->IsConsString()) return Handle<Code>::null();
           return isolate()->stub_cache()->ComputeLoadConstant(
               name, receiver, holder, constant);
           if (constant->IsConsString()) break;
           return compiler.CompileLoadConstant(receiver, holder, name, constant);
+        }
         case NORMAL:
           if (kind() != Code::LOAD_IC) break;
           if (holder->IsGlobalObject()) {
             Handle<GlobalObject> global = Handle<GlobalObject>::cast(holder);
             Handle<PropertyCell> cell(
                 global->GetPropertyCell(lookup), isolate());
             // TODO(verwaest): Turn into a handler.
             return isolate()->stub_cache()->ComputeLoadGlobal(
                 name, receiver, global, cell, lookup->IsDontDelete());
+          }
-...
           // property must be found in the receiver for the stub to be
           // applicable.
           if (!holder.is_identical_to(receiver)) break;
           return isolate()->stub_cache()->ComputeLoadNormal(name, receiver);
           return isolate()->builtins()->LoadIC_Normal();
         case CALLBACKS: {
           // Use simple field loads for some well-known callback properties.
           int object_offset;
           Handle<Map> map(receiver->map());
           if (Accessors::IsJSObjectFieldAccessor(map, name, &object_offset)) {
             PropertyIndex index =
                 PropertyIndex::NewHeaderIndex(object_offset / kPointerSize);
             return compiler.CompileLoadField(
                 receiver, receiver, name, index, Representation::Tagged());
+          }
           Handle<Object> callback(lookup->GetCallbackObject(), isolate());
           if (callback->IsExecutableAccessorInfo()) {
             Handle<ExecutableAccessorInfo> info =
                 Handle<ExecutableAccessorInfo>::cast(callback);
             if (v8::ToCData<Address>(info->getter()) == 0) break;
             if (!info->IsCompatibleReceiver(*receiver)) break;
             return isolate()->stub_cache()->ComputeLoadCallback(
                 name, receiver, holder, info);
             return compiler.CompileLoadCallback(receiver, holder, name, info);
           } else if (callback->IsAccessorPair()) {
             Handle<Object> getter(Handle<AccessorPair>::cast(callback)->getter(),
                                   isolate());
-...
             Handle<JSFunction> function = Handle<JSFunction>::cast(getter);
             CallOptimization call_optimization(function);
             if (call_optimization.is_simple_api_call() &&
                 call_optimization.IsCompatibleReceiver(*receiver) &&
                 FLAG_js_accessor_ics) {
               return isolate()->stub_cache()->ComputeLoadCallback(
                   name, receiver, holder, call_optimization);
                 call_optimization.IsCompatibleReceiver(*receiver)) {
               return compiler.CompileLoadCallback(
                   receiver, holder, name, call_optimization);
+            }
             return isolate()->stub_cache()->ComputeLoadViaGetter(
                 name, receiver, holder, function);
           } else if (receiver->IsJSArray() &&
               name->Equals(isolate()->heap()->length_string())) {
             PropertyIndex lengthIndex =
               PropertyIndex::NewHeaderIndex(JSArray::kLengthOffset / kPointerSize);
             return isolate()->stub_cache()->ComputeLoadField(
                 name, receiver, holder, lengthIndex, Representation::Tagged());
             return compiler.CompileLoadViaGetter(receiver, holder, name, function);
+          }
           // TODO(dcarney): Handle correctly.
           if (callback->IsDeclaredAccessorInfo()) break;
-...
+        }
         case INTERCEPTOR:
           ASSERT(HasInterceptorGetter(*holder));
           return isolate()->stub_cache()->ComputeLoadInterceptor(
               name, receiver, holder);
           return compiler.CompileLoadInterceptor(receiver, holder, name);
         default:
           break;
+      }
       return Handle<Code>::null();
       return slow_stub();
+    }
-...
     Handle<Code> KeyedLoadIC::LoadElementStub(Handle<JSObject> receiver) {
       State ic_state = target()->ic_state();
       // Don't handle megamorphic property accesses for INTERCEPTORS or CALLBACKS
       // via megamorphic stubs, since they don't have a map in their relocation info
       // and so the stubs can't be harvested for the object needed for a map check.
-...
       Handle<Map> receiver_map(receiver->map(), isolate());
       MapHandleList target_receiver_maps;
       if (ic_state == UNINITIALIZED || ic_state == PREMONOMORPHIC) {
       if (state() == UNINITIALIZED || state() == PREMONOMORPHIC) {
         // Optimistically assume that ICs that haven't reached the MONOMORPHIC state
         // yet will do so and stay there.
         return isolate()->stub_cache()->ComputeKeyedLoadElement(receiver_map);
+      }
       if (target() == *string_stub()) {
       if (target().is_identical_to(string_stub())) {
         target_receiver_maps.Add(isolate()->factory()->string_map());
       } else {
         GetReceiverMapsForStub(Handle<Code>(target(), isolate()),
                                &target_receiver_maps);
         target()->FindAllMaps(&target_receiver_maps);
         if (target_receiver_maps.length() == 0) {
           return isolate()->stub_cache()->ComputeKeyedLoadElement(receiver_map);
+        }
-...
       // monomorphic. If this optimistic assumption is not true, the IC will
       // miss again and it will become polymorphic and support both the
       // untransitioned and transitioned maps.
       if (ic_state == MONOMORPHIC &&
       if (state() == MONOMORPHIC &&
           IsMoreGeneralElementsKindTransition(
               target_receiver_maps.at(0)->elements_kind(),
               receiver->GetElementsKind())) {
         return isolate()->stub_cache()->ComputeKeyedLoadElement(receiver_map);
+      }
       ASSERT(ic_state != GENERIC);
       ASSERT(state() != GENERIC);
       // Determine the list of receiver maps that this call site has seen,
       // adding the map that was just encountered.
-...
+    }
     MaybeObject* KeyedLoadIC::Load(State state,
                                    Handle<Object> object,
     MaybeObject* KeyedLoadIC::Load(Handle<Object> object,
                                    Handle<Object> key,
                                    ICMissMode miss_mode) {
       if (MigrateDeprecated(object)) {
         return Runtime::GetObjectPropertyOrFail(isolate(), object, key);
+      }
       MaybeObject* maybe_object = NULL;
       Handle<Code> stub = generic_stub();
       // Check for values that can be converted into an internalized string directly
       // or is representable as a smi.
       key = TryConvertKey(key, isolate());
       if (key->IsInternalizedString()) {
         return LoadIC::Load(state, object, Handle<String>::cast(key));
+      }
       bool use_ic = FLAG_use_ic && !object->IsAccessCheckNeeded();
       ASSERT(!(use_ic && object->IsJSGlobalProxy()));
       if (use_ic) {
         Handle<Code> stub = generic_stub();
         maybe_object = LoadIC::Load(object, Handle<String>::cast(key));
         if (maybe_object->IsFailure()) return maybe_object;
       } else if (FLAG_use_ic && !object->IsAccessCheckNeeded()) {
         ASSERT(!object->IsJSGlobalProxy());
         if (miss_mode != MISS_FORCE_GENERIC) {
           if (object->IsString() && key->IsNumber()) {
             if (state == UNINITIALIZED) {
               stub = string_stub();
+            }
             if (state() == UNINITIALIZED) stub = string_stub();
           } else if (object->IsJSObject()) {
             Handle<JSObject> receiver = Handle<JSObject>::cast(object);
             if (receiver->map()->is_deprecated()) {
               JSObject::MigrateInstance(receiver);
+            }
             if (receiver->elements()->map() ==
                 isolate()->heap()->non_strict_arguments_elements_map()) {
               stub = non_strict_arguments_stub();
             } else if (receiver->HasIndexedInterceptor()) {
               stub = indexed_interceptor_stub();
             } else if (!key->ToSmi()->IsFailure() &&
                        (target() != *non_strict_arguments_stub())) {
                        (!target().is_identical_to(non_strict_arguments_stub()))) {
               stub = LoadElementStub(receiver);
+            }
+          }
         } else {
           TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "force generic");
+        }
+      }
       if (!is_target_set()) {
         if (*stub == *generic_stub()) {
           TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "set generic");
+        }
         ASSERT(!stub.is_null());
         set_target(*stub);
         TRACE_IC("KeyedLoadIC", key, state, target());
         TRACE_IC("LoadIC", key);
+      }
       if (maybe_object != NULL) return maybe_object;
       return Runtime::GetObjectPropertyOrFail(isolate(), object, key);
+    }
     Handle<Code> KeyedLoadIC::ComputeLoadHandler(LookupResult* lookup,
                                                  Handle<JSObject> receiver,
                                                  Handle<String> name) {
       // Bail out if we didn't find a result.
       if (!lookup->IsProperty()) return Handle<Code>::null();
       // Compute a monomorphic stub.
       Handle<JSObject> holder(lookup->holder(), isolate());
       switch (lookup->type()) {
         case FIELD:
           return isolate()->stub_cache()->ComputeKeyedLoadField(
               name, receiver, holder,
               lookup->GetFieldIndex(), lookup->representation());
         case CONSTANT: {
           Handle<Object> constant(lookup->GetConstant(), isolate());
           // TODO(2803): Don't compute a stub for cons strings because they cannot
           // be embedded into code.
           if (constant->IsConsString()) return Handle<Code>::null();
           return isolate()->stub_cache()->ComputeKeyedLoadConstant(
               name, receiver, holder, constant);
+        }
         case CALLBACKS: {
           Handle<Object> callback_object(lookup->GetCallbackObject(), isolate());
           // TODO(dcarney): Handle DeclaredAccessorInfo correctly.
           if (callback_object->IsExecutableAccessorInfo()) {
             Handle<ExecutableAccessorInfo> callback =
                 Handle<ExecutableAccessorInfo>::cast(callback_object);
             if (v8::ToCData<Address>(callback->getter()) == 0) break;
             if (!callback->IsCompatibleReceiver(*receiver)) break;
             return isolate()->stub_cache()->ComputeKeyedLoadCallback(
                 name, receiver, holder, callback);
           } else if (callback_object->IsAccessorPair()) {
             Handle<Object> getter(
                 Handle<AccessorPair>::cast(callback_object)->getter(),
                 isolate());
             if (!getter->IsJSFunction()) break;
             if (holder->IsGlobalObject()) break;
             if (!holder->HasFastProperties()) break;
             Handle<JSFunction> function = Handle<JSFunction>::cast(getter);
             CallOptimization call_optimization(function);
             if (call_optimization.is_simple_api_call() &&
                 call_optimization.IsCompatibleReceiver(*receiver) &&
                 FLAG_js_accessor_ics) {
               return isolate()->stub_cache()->ComputeKeyedLoadCallback(
                   name, receiver, holder, call_optimization);
+            }
+          }
           break;
+        }
         case INTERCEPTOR:
           ASSERT(HasInterceptorGetter(lookup->holder()));
           return isolate()->stub_cache()->ComputeKeyedLoadInterceptor(
               name, receiver, holder);
         default:
           // Always rewrite to the generic case so that we do not
           // repeatedly try to rewrite.
           return generic_stub();
+      }
       return Handle<Code>::null();
+    }

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff