[strong] Implement strong mode restrictions on property access

src/ic/ic-state.h

 // 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.
 
 #ifndef V8_IC_STATE_H_
 #define V8_IC_STATE_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 183 matching lines @@
 
   static const char* GetStateName(CompareICState::State state);
 
   static State TargetState(State old_state, State old_left, State old_right,
                            Token::Value op, bool has_inlined_smi_code,
                            Handle<Object> x, Handle<Object> y);
 };
 
 
 class LoadICState final BASE_EMBEDDED {
+ private:
+  class ContextualModeBits : public BitField<ContextualMode, 0, 1> {};

[Toon Verwaest, 2015/06/09 11:58:04]

Why was this moved up? That looks odd...

[conradw, 2015/06/09 13:09:27]

Because of the initialisation order, if I want to be able to have a static
member kStrongModeState inititalised using the bitfield then the bitfield needs
to be declared first.

In StoreICState where something similar is done, the bitfield is declared as
public, in an order which gets around this. Not sure which is better.

+  class StrengthBits : public BitField<bool, 1, 1> {};
+  STATIC_ASSERT(static_cast<int>(NOT_CONTEXTUAL) == 0);
+  const ExtraICState state_;
+
  public:
+  static const ExtraICState kStrongModeState = 1 << StrengthBits::kShift;
+
   explicit LoadICState(ExtraICState extra_ic_state) : state_(extra_ic_state) {}
 
-  explicit LoadICState(ContextualMode mode)
-      : state_(ContextualModeBits::encode(mode)) {}
+  explicit LoadICState(ContextualMode mode, Strength strength)
+      : state_(ContextualModeBits::encode(mode) |
+               StrengthBits::encode(is_strong(strength))) {}
 
   ExtraICState GetExtraICState() const { return state_; }
 
   ContextualMode contextual_mode() const {
     return ContextualModeBits::decode(state_);
   }
 
+  Strength strength() const {
+    return StrengthBits::decode(state_) ? Strength::STRONG : Strength::WEAK;
+  }
+
   static ContextualMode GetContextualMode(ExtraICState state) {
     return LoadICState(state).contextual_mode();
   }
 
- private:
-  class ContextualModeBits : public BitField<ContextualMode, 0, 1> {};
-  STATIC_ASSERT(static_cast<int>(NOT_CONTEXTUAL) == 0);
-
-  const ExtraICState state_;
+  static Strength GetStrength(ExtraICState state) {
+    return LoadICState(state).strength();
+  }
 };
 
 
 class StoreICState final BASE_EMBEDDED {
  public:
   explicit StoreICState(ExtraICState extra_ic_state) : state_(extra_ic_state) {}
 
   explicit StoreICState(LanguageMode mode)
       : state_(LanguageModeState::encode(mode)) {}
 
@@ skipping 15 matching lines @@
   static const ExtraICState kStrictModeState = STRICT
                                                << LanguageModeState::kShift;
 
  private:
   const ExtraICState state_;
 };
 }
 }
 
 #endif  // V8_IC_STATE_H_