[strong] Implement strong mode restrictions on property access

src/ic/ic.h

Index: src/ic/ic.h
diff --git a/src/ic/ic.h b/src/ic/ic.h
index c346306370645d9dcfcc715d19d46bcfcc4fbe1a..daaeccea866b5f1bc053a11ceb33cfb7e917bfae 100644
--- a/src/ic/ic.h
+++ b/src/ic/ic.h
@@ -18,6 +18,8 @@ namespace internal {
 #define IC_UTIL_LIST(ICU)              \
   ICU(LoadIC_Miss)                     \
   ICU(KeyedLoadIC_Miss)                \
+  ICU(LoadIC_Slow)                     \
+  ICU(KeyedLoadIC_Slow)                \
   ICU(CallIC_Miss)                     \
   ICU(CallIC_Customization_Miss)       \
   ICU(StoreIC_Miss)                    \
@@ -352,14 +354,19 @@ class CallIC : public IC {
 
 class LoadIC : public IC {
  public:
-  static ExtraICState ComputeExtraICState(ContextualMode contextual_mode) {
-    return LoadICState(contextual_mode).GetExtraICState();
+  static ExtraICState ComputeExtraICState(ContextualMode contextual_mode,
+                                          Strength strength) {
+    return LoadICState(contextual_mode, strength).GetExtraICState();
   }
 
   ContextualMode contextual_mode() const {
     return LoadICState::GetContextualMode(extra_ic_state());
   }
 
+  Strength strength() const {
+    return LoadICState::GetStrength(extra_ic_state());
+  }
+
   LoadIC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus = NULL)
       : IC(depth, isolate, nexus) {
     DCHECK(nexus != NULL);
@@ -390,7 +397,7 @@ class LoadIC : public IC {
   static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
   static void GenerateMiss(MacroAssembler* masm);
   static void GenerateNormal(MacroAssembler* masm);
-  static void GenerateRuntimeGetProperty(MacroAssembler* masm);
+  static void GenerateSlow(MacroAssembler* masm);
 
   static Handle<Code> initialize_stub(Isolate* isolate,
                                       ExtraICState extra_state);
@@ -437,11 +444,12 @@ class LoadIC : public IC {
 class KeyedLoadIC : public LoadIC {
  public:
   // ExtraICState bits (building on IC)
-  class IcCheckTypeField : public BitField<IcCheckType, 1, 1> {};
+  class IcCheckTypeField : public BitField<IcCheckType, 2, 1> {};
 
   static ExtraICState ComputeExtraICState(ContextualMode contextual_mode,
+                                          Strength strength,
                                           IcCheckType key_type) {
-    return LoadICState(contextual_mode).GetExtraICState() |
+    return LoadICState(contextual_mode, strength).GetExtraICState() |
            IcCheckTypeField::encode(key_type);
   }
 
@@ -461,9 +469,9 @@ class KeyedLoadIC : public LoadIC {
 
   // Code generator routines.
   static void GenerateMiss(MacroAssembler* masm);
-  static void GenerateRuntimeGetProperty(MacroAssembler* masm);
+  static void GenerateSlow(MacroAssembler* masm);
   static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
-  static void GenerateMegamorphic(MacroAssembler* masm);
+  static void GenerateMegamorphic(MacroAssembler* masm, Strength strength);
 
   // Bit mask to be tested against bit field for the cases when
   // generic stub should go into slow case.
@@ -472,10 +480,12 @@ class KeyedLoadIC : public LoadIC {
   static const int kSlowCaseBitFieldMask =
       (1 << Map::kIsAccessCheckNeeded) | (1 << Map::kHasIndexedInterceptor);
 
-  static Handle<Code> initialize_stub(Isolate* isolate);
+  static Handle<Code> initialize_stub(Isolate* isolate,
+                                      ExtraICState extra_state);
   static Handle<Code> initialize_stub_in_optimized_code(
-      Isolate* isolate, State initialization_state);
-  static Handle<Code> ChooseMegamorphicStub(Isolate* isolate);
+      Isolate* isolate, State initialization_state, ExtraICState extra_state);
+  static Handle<Code> ChooseMegamorphicStub(Isolate* isolate,
+                                            ExtraICState extra_state);
 
   static void Clear(Isolate* isolate, Code* host, KeyedLoadICNexus* nexus);