Avoid flushing the icache unnecessarily when updating target addresses in code.

src/ic.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "v8.h"
 
 #include "accessors.h"
 #include "api.h"
 #include "arguments.h"
 #include "codegen.h"
@@ skipping 841 matching lines @@
 }
 
 
 void LoadIC::UpdateCaches(LookupResult* lookup,
                           Handle<Object> object,
                           Handle<String> name) {
   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.
-    set_target(*pre_monomorphic_stub());
+    // No need to flush the icache since the pre_monomorphic_stub will be the
+    // same code as the initialize_stub - it is just used as a marker to
+    // identify when we should move to monomorphic, and will be correctly read
+    // via raw_target() even if the wrong stub was called.
+    set_target(*pre_monomorphic_stub(), SKIP_ICACHE_FLUSH_IF_ATOMIC);
     TRACE_IC("LoadIC", name);
     return;
   }
 
   Handle<HeapType> type = CurrentTypeOf(object, isolate());
   Handle<Code> code;
   if (!lookup->IsCacheable()) {
     // Bail out if the result is not cacheable.
     code = slow_stub();
   } else if (!lookup->IsProperty()) {
@@ skipping 429 matching lines @@
   if (!can_store &&
       strict_mode() == STRICT &&
       !(lookup.IsProperty() && lookup.IsReadOnly()) &&
       object->IsGlobalObject()) {
     // Strict mode doesn't allow setting non-existent global property.
     return ReferenceError("not_defined", name);
   }
   if (FLAG_use_ic) {
     if (state() == UNINITIALIZED) {
       Handle<Code> stub = pre_monomorphic_stub();
-      set_target(*stub);
+      // No need to flush the icache since the pre_monomorphic_stub will be the
+      // same code as the initialize_stub - it is just used as a marker to
+      // identify when we should move to monomorphic, and will be correctly read
+      // via raw_target() even if the wrong stub was called.
+      set_target(*stub, SKIP_ICACHE_FLUSH_IF_ATOMIC);
       TRACE_IC("StoreIC", name);
     } else if (can_store) {
       UpdateCaches(&lookup, receiver, name, value);
     } else if (!name->IsCacheable(isolate()) ||
                lookup.IsNormal() ||
                (lookup.IsField() && lookup.CanHoldValue(value))) {
       Handle<Code> stub = generic_stub();
       set_target(*stub);
     }
   }
@@ skipping 1662 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal