A64: Synchronize with r18147.

src/code-stubs.h

 // 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 181 matching lines @@
   // Lookup the code in the (possibly custom) cache.
   bool FindCodeInCache(Code** code_out, Isolate* isolate);
 
   // Returns information for computing the number key.
   virtual Major MajorKey() = 0;
   virtual int MinorKey() = 0;
 
   virtual InlineCacheState GetICState() {
     return UNINITIALIZED;
   }
-  virtual Code::ExtraICState GetExtraICState() {
-    return Code::kNoExtraICState;
+  virtual ExtraICState GetExtraICState() {
+    return kNoExtraICState;
   }
   virtual Code::StubType GetStubType() {
     return Code::NORMAL;
   }
   virtual int GetStubFlags() {
     return -1;
   }
 
   virtual void PrintName(StringStream* stream);
 
@@ skipping 633 matching lines @@
     virtual CodeStub::Major MajorKey() { return StringLength; }
 };
 
 
 class StoreICStub: public ICStub {
  public:
   StoreICStub(Code::Kind kind, StrictModeFlag strict_mode)
       : ICStub(kind), strict_mode_(strict_mode) { }
 
  protected:
-  virtual Code::ExtraICState GetExtraICState() {
-    return strict_mode_;
+  virtual ExtraICState GetExtraICState() {
+    return StoreIC::ComputeExtraICState(strict_mode_);
   }
 
  private:
   STATIC_ASSERT(KindBits::kSize == 4);
   class StrictModeBits: public BitField<bool, 4, 1> {};
   virtual int MinorKey() {
     return KindBits::encode(kind()) | StrictModeBits::encode(strict_mode_);
   }
 
   StrictModeFlag strict_mode_;
@@ skipping 90 matching lines @@
   STATIC_ASSERT(KindBits::kSize == 4);
   class InobjectBits: public BitField<bool, 4, 1> {};
   class IndexBits: public BitField<int, 5, 11> {};
   class UnboxedDoubleBits: public BitField<bool, 16, 1> {};
   virtual CodeStub::Major MajorKey() { return LoadField; }
 };
 
 
 class StoreGlobalStub : public HandlerStub {
  public:
-  StoreGlobalStub(StrictModeFlag strict_mode, bool is_constant) {
-    bit_field_ = StrictModeBits::encode(strict_mode) |
-        IsConstantBits::encode(is_constant);
+  explicit StoreGlobalStub(bool is_constant) {
+    bit_field_ = IsConstantBits::encode(is_constant);
   }
 
   Handle<Code> GetCodeCopyFromTemplate(Isolate* isolate,
                                        Map* receiver_map,
                                        PropertyCell* cell) {
     Handle<Code> code = CodeStub::GetCodeCopyFromTemplate(isolate);
     // Replace the placeholder cell and global object map with the actual global
     // cell and receiver map.
     Map* cell_map = isolate->heap()->global_property_cell_map();
     code->ReplaceNthObject(1, cell_map, cell);
     code->ReplaceNthObject(1, isolate->heap()->meta_map(), receiver_map);
     return code;
   }
 
   virtual Code::Kind kind() const { return Code::STORE_IC; }
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
-  virtual Code::ExtraICState GetExtraICState() { return bit_field_; }
+  virtual ExtraICState GetExtraICState() { return bit_field_; }
 
   bool is_constant() {
     return IsConstantBits::decode(bit_field_);
   }
   void set_is_constant(bool value) {
     bit_field_ = IsConstantBits::update(bit_field_, value);
   }
 
   Representation representation() {
     return Representation::FromKind(RepresentationBits::decode(bit_field_));
   }
   void set_representation(Representation r) {
     bit_field_ = RepresentationBits::update(bit_field_, r.kind());
   }
 
  private:
   virtual int NotMissMinorKey() { return GetExtraICState(); }
   Major MajorKey() { return StoreGlobal; }
 
-  class StrictModeBits: public BitField<StrictModeFlag, 0, 1> {};
-  class IsConstantBits: public BitField<bool, 1, 1> {};
-  class RepresentationBits: public BitField<Representation::Kind, 2, 8> {};
+  class IsConstantBits: public BitField<bool, 0, 1> {};
+  class RepresentationBits: public BitField<Representation::Kind, 1, 8> {};
 
   int bit_field_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreGlobalStub);
 };
 
 
 class KeyedLoadFieldStub: public LoadFieldStub {
  public:
   KeyedLoadFieldStub(bool inobject, int index, Representation representation)
@@ skipping 12 matching lines @@
 };
 
 
 class KeyedArrayCallStub: public HICStub {
  public:
   KeyedArrayCallStub(bool holey, int argc) : HICStub(), argc_(argc) {
     bit_field_ = ContextualBits::encode(false) | HoleyBits::encode(holey);
   }
 
   virtual Code::Kind kind() const { return Code::KEYED_CALL_IC; }
-  virtual Code::ExtraICState GetExtraICState() { return bit_field_; }
+  virtual ExtraICState GetExtraICState() { return bit_field_; }
 
   ElementsKind elements_kind() {
     return HoleyBits::decode(bit_field_) ? FAST_HOLEY_ELEMENTS : FAST_ELEMENTS;
   }
 
   int argc() { return argc_; }
   virtual int GetStubFlags() { return argc(); }
 
   static bool IsHoley(Handle<Code> code) {
-    Code::ExtraICState state = code->extra_ic_state();
+    ExtraICState state = code->extra_ic_state();
     return HoleyBits::decode(state);
   }
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
 
  private:
@@ skipping 14 matching lines @@
 
 
 class BinaryOpStub: public HydrogenCodeStub {
  public:
   BinaryOpStub(Token::Value op, OverwriteMode mode)
       : HydrogenCodeStub(UNINITIALIZED), op_(op), mode_(mode) {
     ASSERT(op <= LAST_TOKEN && op >= FIRST_TOKEN);
     Initialize();
   }
 
-  explicit BinaryOpStub(Code::ExtraICState state)
+  explicit BinaryOpStub(ExtraICState state)
       : op_(decode_token(OpBits::decode(state))),
         mode_(OverwriteModeField::decode(state)),
         fixed_right_arg_(
             Maybe<int>(HasFixedRightArgBits::decode(state),
                 decode_arg_value(FixedRightArgValueBits::decode(state)))),
         left_state_(LeftStateField::decode(state)),
         right_state_(fixed_right_arg_.has_value
             ? ((fixed_right_arg_.value <= Smi::kMaxValue) ? SMI : INT32)
             : RightStateField::decode(state)),
         result_state_(ResultStateField::decode(state)) {
@@ skipping 22 matching lines @@
       return ::v8::internal::UNINITIALIZED;
     }
     if (Max(left_state_, right_state_) == GENERIC) return MEGAMORPHIC;
     return MONOMORPHIC;
   }
 
   virtual void VerifyPlatformFeatures(Isolate* isolate) V8_OVERRIDE {
     ASSERT(CpuFeatures::VerifyCrossCompiling(SSE2));
   }
 
-  virtual Code::ExtraICState GetExtraICState() {
+  virtual ExtraICState GetExtraICState() {
     bool sse_field = Max(result_state_, Max(left_state_, right_state_)) > SMI &&
                      CpuFeatures::IsSafeForSnapshot(SSE2);
 
     return OpBits::encode(encode_token(op_))
          | LeftStateField::encode(left_state_)
          | RightStateField::encode(fixed_right_arg_.has_value
                                        ? NONE : right_state_)
          | ResultStateField::encode(result_state_)
          | HasFixedRightArgBits::encode(fixed_right_arg_.has_value)
          | FixedRightArgValueBits::encode(fixed_right_arg_.has_value
@@ skipping 219 matching lines @@
 };
 
 
 class CompareNilICStub : public HydrogenCodeStub  {
  public:
   Handle<Type> GetType(Isolate* isolate, Handle<Map> map = Handle<Map>());
   Handle<Type> GetInputType(Isolate* isolate, Handle<Map> map);
 
   explicit CompareNilICStub(NilValue nil) : nil_value_(nil) { }
 
-  CompareNilICStub(Code::ExtraICState ic_state,
+  CompareNilICStub(ExtraICState ic_state,
                    InitializationState init_state = INITIALIZED)
       : HydrogenCodeStub(init_state),
         nil_value_(NilValueField::decode(ic_state)),
         state_(State(TypesField::decode(ic_state))) {
       }
 
   static Handle<Code> GetUninitialized(Isolate* isolate,
                                        NilValue nil) {
     return CompareNilICStub(nil, UNINITIALIZED).GetCode(isolate);
   }
@@ skipping 16 matching lines @@
       return MONOMORPHIC;
     } else {
       return PREMONOMORPHIC;
     }
   }
 
   virtual Code::Kind GetCodeKind() const { return Code::COMPARE_NIL_IC; }
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
 
-  virtual Code::ExtraICState GetExtraICState() {
+  virtual ExtraICState GetExtraICState() {
     return NilValueField::encode(nil_value_) |
            TypesField::encode(state_.ToIntegral());
   }
 
   void UpdateStatus(Handle<Object> object);
 
   bool IsMonomorphic() const { return state_.Contains(MONOMORPHIC_MAP); }
   NilValue GetNilValue() const { return nil_value_; }
   void ClearState() { state_.RemoveAll(); }
 
@@ skipping 932 matching lines @@
     bool UpdateStatus(Handle<Object> object);
     bool NeedsMap() const;
     bool CanBeUndetectable() const;
     bool IsGeneric() const { return ToIntegral() == Generic().ToIntegral(); }
 
     static Types Generic() { return Types((1 << NUMBER_OF_TYPES) - 1); }
   };
 
   explicit ToBooleanStub(Types types = Types())
       : types_(types) { }
-  explicit ToBooleanStub(Code::ExtraICState state)
+  explicit ToBooleanStub(ExtraICState state)
       : types_(static_cast<byte>(state)) { }
 
   bool UpdateStatus(Handle<Object> object);
   Types GetTypes() { return types_; }
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
   virtual Code::Kind GetCodeKind() const { return Code::TO_BOOLEAN_IC; }
   virtual void PrintState(StringStream* stream);
 
   virtual bool SometimesSetsUpAFrame() { return false; }
 
   static void InitializeForIsolate(Isolate* isolate) {
     ToBooleanStub stub;
     stub.InitializeInterfaceDescriptor(
         isolate,
         isolate->code_stub_interface_descriptor(CodeStub::ToBoolean));
   }
 
   static Handle<Code> GetUninitialized(Isolate* isolate) {
     return ToBooleanStub(UNINITIALIZED).GetCode(isolate);
   }
 
-  virtual Code::ExtraICState GetExtraICState() {
+  virtual ExtraICState GetExtraICState() {
     return types_.ToIntegral();
   }
 
   virtual InlineCacheState GetICState() {
     if (types_.IsEmpty()) {
       return ::v8::internal::UNINITIALIZED;
     } else {
       return MONOMORPHIC;
     }
   }
@@ skipping 141 matching lines @@
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 
   DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_