Add premonomorphic store ICs.

src/ic.cc

 // Copyright 2012 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 1691 matching lines @@
           ? global_proxy_stub_strict()
           : global_proxy_stub();
       set_target(*stub);
       TRACE_IC("StoreIC", name, state, *stub);
     }
     return JSReceiver::SetPropertyOrFail(
         receiver, name, value, NONE, strict_mode, store_mode);
   }
 
   LookupResult lookup(isolate());
-  if (LookupForWrite(receiver, name, value, &lookup, &state)) {
-    if (FLAG_use_ic) {
-      UpdateCaches(&lookup, state, strict_mode, receiver, name, value);
-    }
-  } else if (strict_mode == kStrictMode &&
-             !(lookup.IsProperty() && lookup.IsReadOnly()) &&
-             IsUndeclaredGlobal(object)) {
+  bool can_store = LookupForWrite(receiver, name, value, &lookup, &state);
+  if (!can_store &&

[Jakob Kummerow, 2013/09/03 09:58:59]

nit: I'm finding this heterogeneous if/else cascade a little hard to read, and I
think I'd prefer the following alternative formatting:

  bool can_store = LookupForWrite(receiver, name, value, &lookup, &state);
  if (!can_store &&
      strict_mode == kStrictMode &&
      !(lookup.IsProperty() && lookup.IsReadOnly()) &&
      IsUndeclaredGlobal(object)) {
    // 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 = (strict_mode == kStrictMode)
          ? pre_monomorphic_stub_strict()
          : pre_monomorphic_stub();
      set_target(*stub);
      TRACE_IC("StoreIC", name, state, *stub);
    } else if (can_store) {
      UpdateCaches(&lookup, state, strict_mode, receiver, name, value);
    } else if (!name->IsCacheable(isolate()) ||
               lookup.IsNormal() ||
               (lookup.IsField() && lookup.CanHoldValue(value))) {
      Handle<Code> stub = (strict_mode == kStrictMode) ? generic_stub_strict()
                                                       : generic_stub();
      set_target(*stub);
    }
  }

I leave the decision up to you, though.

+      strict_mode == kStrictMode &&
+      !(lookup.IsProperty() && lookup.IsReadOnly()) &&
+      IsUndeclaredGlobal(object)) {
     // Strict mode doesn't allow setting non-existent global property.
     return ReferenceError("not_defined", name);
+  } else if (FLAG_use_ic && state == UNINITIALIZED) {
+    Handle<Code> stub = (strict_mode == kStrictMode)
+        ? pre_monomorphic_stub_strict()
+        : pre_monomorphic_stub();
+    set_target(*stub);
+    TRACE_IC("StoreIC", name, state, *stub);
+  } else if (FLAG_use_ic && can_store) {
+    UpdateCaches(&lookup, state, strict_mode, receiver, name, value);
   } else if (FLAG_use_ic &&
              (!name->IsCacheable(isolate()) ||
               lookup.IsNormal() ||
               (lookup.IsField() && lookup.CanHoldValue(value)))) {
     Handle<Code> stub = strict_mode == kStrictMode
         ? generic_stub_strict() : generic_stub();
     set_target(*stub);
   }
 
   // Set the property.
@@ skipping 1364 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal