Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/ic/ic.h b/src/ic/ic.h
index 541fa0c..a3265d7 100644
--- a/src/ic/ic.h
+++ b/src/ic/ic.h
@@ -7,49 +7,16 @@
#include "src/ic/ic-state.h"
#include "src/macro-assembler.h"
+#include "src/messages.h"
namespace v8 {
namespace internal {
-
-// IC_UTIL_LIST defines all utility functions called from generated
-// inline caching code. The argument for the macro, ICU, is the function name.
-#define IC_UTIL_LIST(ICU) \
- ICU(LoadIC_Miss) \
- ICU(KeyedLoadIC_Miss) \
- ICU(CallIC_Miss) \
- ICU(CallIC_Customization_Miss) \
- ICU(StoreIC_Miss) \
- ICU(StoreIC_Slow) \
- ICU(KeyedStoreIC_Miss) \
- ICU(KeyedStoreIC_Slow) \
- /* Utilities for IC stubs. */ \
- ICU(StoreCallbackProperty) \
- ICU(LoadPropertyWithInterceptorOnly) \
- ICU(LoadPropertyWithInterceptor) \
- ICU(LoadElementWithInterceptor) \
- ICU(StorePropertyWithInterceptor) \
- ICU(CompareIC_Miss) \
- ICU(BinaryOpIC_Miss) \
- ICU(CompareNilIC_Miss) \
- ICU(Unreachable) \
- ICU(ToBooleanIC_Miss)
//
// IC is the base class for LoadIC, StoreIC, KeyedLoadIC, and KeyedStoreIC.
//
class IC {
public:
- // The ids for utility called from the generated code.
- enum UtilityId {
-#define CONST_NAME(name) k##name,
- IC_UTIL_LIST(CONST_NAME)
-#undef CONST_NAME
- kUtilityCount
- };
-
- // Looks up the address of the named utility.
- static Address AddressFromUtilityId(UtilityId id);
-
// Alias the inline cache state type to make the IC code more readable.
typedef InlineCacheState State;
@@ -59,8 +26,7 @@
// Construct the IC structure with the given number of extra
// JavaScript frames on the stack.
- IC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus = NULL,
- bool for_queries_only = false);
+ IC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus = NULL);
virtual ~IC() {}
State state() const { return state_; }
@@ -77,8 +43,7 @@
}
// Clear the inline cache to initial state.
- static void Clear(Isolate* isolate, Address address,
- ConstantPoolArray* constant_pool);
+ static void Clear(Isolate* isolate, Address address, Address constant_pool);
#ifdef DEBUG
bool IsLoadStub() const {
@@ -92,43 +57,28 @@
bool IsCallStub() const { return target()->is_call_stub(); }
#endif
- template <class TypeClass>
- static JSFunction* GetRootConstructor(TypeClass* type,
- Context* native_context);
- static inline Handle<Map> GetHandlerCacheHolder(HeapType* type,
+ static inline Handle<Map> GetHandlerCacheHolder(Handle<Map> receiver_map,
bool receiver_is_holder,
Isolate* isolate,
CacheHolderFlag* flag);
- static inline Handle<Map> GetICCacheHolder(HeapType* type, Isolate* isolate,
+ static inline Handle<Map> GetICCacheHolder(Handle<Map> receiver_map,
+ Isolate* isolate,
CacheHolderFlag* flag);
static bool IsCleared(Code* code) {
InlineCacheState state = code->ic_state();
- return state == UNINITIALIZED || state == PREMONOMORPHIC;
+ return !FLAG_use_ic || state == UNINITIALIZED || state == PREMONOMORPHIC;
}
static bool IsCleared(FeedbackNexus* nexus) {
InlineCacheState state = nexus->StateFromFeedback();
- return state == UNINITIALIZED || state == PREMONOMORPHIC;
+ return !FLAG_use_ic || state == UNINITIALIZED || state == PREMONOMORPHIC;
}
- // Utility functions to convert maps to types and back. There are two special
- // cases:
- // - The heap_number_map is used as a marker which includes heap numbers as
- // well as smis.
- // - The oddball map is only used for booleans.
- static Handle<Map> TypeToMap(HeapType* type, Isolate* isolate);
- template <class T>
- static typename T::TypeHandle MapToType(Handle<Map> map,
- typename T::Region* region);
-
- static Handle<HeapType> CurrentTypeOf(Handle<Object> object,
- Isolate* isolate);
-
static bool ICUseVector(Code::Kind kind) {
- return (FLAG_vector_ics &&
- (kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC)) ||
- kind == Code::CALL_IC;
+ return kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC ||
+ kind == Code::CALL_IC || kind == Code::STORE_IC ||
+ kind == Code::KEYED_STORE_IC;
}
protected:
@@ -143,12 +93,16 @@
SharedFunctionInfo* GetSharedFunctionInfo() const;
// Get the code object of the caller.
Code* GetCode() const;
- // Get the original (non-breakpointed) code object of the caller.
- Code* GetOriginalCode() const;
+
+ bool AddressIsOptimizedCode() const;
+ inline bool AddressIsDeoptimizedCode() const;
+ inline static bool AddressIsDeoptimizedCode(Isolate* isolate,
+ Address address);
// Set the call-site target.
inline void set_target(Code* code);
bool is_target_set() { return target_set_; }
+ bool is_vector_set() { return vector_set_; }
bool UseVector() const {
bool use = ICUseVector(kind());
@@ -160,10 +114,15 @@
// Configure for most states.
void ConfigureVectorState(IC::State new_state);
// Configure the vector for MONOMORPHIC.
- void ConfigureVectorState(Handle<Name> name, Handle<HeapType> type,
+ void ConfigureVectorState(Handle<Name> name, Handle<Map> map,
Handle<Code> handler);
// Configure the vector for POLYMORPHIC.
- void ConfigureVectorState(Handle<Name> name, TypeHandleList* types,
+ void ConfigureVectorState(Handle<Name> name, MapHandleList* maps,
+ CodeHandleList* handlers);
+ // Configure the vector for POLYMORPHIC with transitions (only for element
+ // keyed stores).
+ void ConfigureVectorState(MapHandleList* maps,
+ MapHandleList* transitioned_maps,
CodeHandleList* handlers);
char TransitionMarkFromState(IC::State state);
@@ -171,22 +130,20 @@
void TraceIC(const char* type, Handle<Object> name, State old_state,
State new_state);
- MaybeHandle<Object> TypeError(const char* type, Handle<Object> object,
- Handle<Object> key);
- MaybeHandle<Object> ReferenceError(const char* type, Handle<Name> name);
+ MaybeHandle<Object> TypeError(MessageTemplate::Template,
+ Handle<Object> object, Handle<Object> key);
+ MaybeHandle<Object> ReferenceError(Handle<Name> name);
// Access the target code for the given IC address.
static inline Code* GetTargetAtAddress(Address address,
- ConstantPoolArray* constant_pool);
+ Address constant_pool);
static inline void SetTargetAtAddress(Address address, Code* target,
- ConstantPoolArray* constant_pool);
+ Address constant_pool);
static void OnTypeFeedbackChanged(Isolate* isolate, Address address,
State old_state, State new_state,
bool target_remains_ic_stub);
// As a vector-based IC, type feedback must be updated differently.
- static void OnTypeFeedbackChanged(Isolate* isolate, Code* host,
- TypeFeedbackVector* vector, State old_state,
- State new_state);
+ static void OnTypeFeedbackChanged(Isolate* isolate, Code* host);
static void PostPatching(Address address, Code* target, Code* old_target);
// Compute the handler either by compiling or by retrieving a cached version.
@@ -201,7 +158,7 @@
void UpdateMonomorphicIC(Handle<Code> handler, Handle<Name> name);
bool UpdatePolymorphicIC(Handle<Name> name, Handle<Code> code);
- void UpdateMegamorphicCache(HeapType* type, Name* name, Code* code);
+ void UpdateMegamorphicCache(Map* map, Name* name, Code* code);
void CopyICToMegamorphicCache(Handle<Name> name);
bool IsTransitionOfMonomorphicTarget(Map* source_map, Map* target_map);
@@ -224,9 +181,13 @@
ExtraICState extra_ic_state() const { return extra_ic_state_; }
void set_extra_ic_state(ExtraICState state) { extra_ic_state_ = state; }
- Handle<HeapType> receiver_type() { return receiver_type_; }
- void update_receiver_type(Handle<Object> receiver) {
- receiver_type_ = CurrentTypeOf(receiver, isolate_);
+ Handle<Map> receiver_map() { return receiver_map_; }
+ void update_receiver_map(Handle<Object> receiver) {
+ if (receiver->IsSmi()) {
+ receiver_map_ = isolate_->factory()->heap_number_map();
+ } else {
+ receiver_map_ = handle(HeapObject::cast(*receiver)->map());
+ }
}
void TargetMaps(MapHandleList* list) {
@@ -236,13 +197,6 @@
}
}
- void TargetTypes(TypeHandleList* list) {
- FindTargetMaps();
- for (int i = 0; i < target_maps_.length(); i++) {
- list->Add(MapToType<HeapType>(target_maps_.at(i), isolate_));
- }
- }
-
Map* FirstTargetMap() {
FindTargetMaps();
return target_maps_.length() > 0 ? *target_maps_.at(0) : NULL;
@@ -251,7 +205,7 @@
inline void UpdateTarget();
Handle<TypeFeedbackVector> vector() const { return nexus()->vector_handle(); }
- FeedbackVectorICSlot slot() const { return nexus()->slot(); }
+ FeedbackVectorSlot slot() const { return nexus()->slot(); }
State saved_state() const {
return state() == PROTOTYPE_FAILURE ? old_state_ : state();
}
@@ -266,8 +220,8 @@
private:
inline Code* raw_target() const;
- inline ConstantPoolArray* constant_pool() const;
- inline ConstantPoolArray* raw_constant_pool() const;
+ inline Address constant_pool() const;
+ inline Address raw_constant_pool() const;
void FindTargetMaps() {
if (target_maps_set_) return;
@@ -287,25 +241,26 @@
// Frame pointer for the frame that uses (calls) the IC.
Address fp_;
- // All access to the program counter of an IC structure is indirect
- // to make the code GC safe. This feature is crucial since
+ // All access to the program counter and constant pool of an IC structure is
+ // indirect to make the code GC safe. This feature is crucial since
// GetProperty and SetProperty are called and they in turn might
// invoke the garbage collector.
Address* pc_address_;
- Isolate* isolate_;
-
// The constant pool of the code which originally called the IC (which might
// be for the breakpointed copy of the original code).
- Handle<ConstantPoolArray> raw_constant_pool_;
+ Address* constant_pool_address_;
+
+ Isolate* isolate_;
// The original code target that missed.
Handle<Code> target_;
bool target_set_;
+ bool vector_set_;
State old_state_; // For saving if we marked as prototype failure.
State state_;
Code::Kind kind_;
- Handle<HeapType> receiver_type_;
+ Handle<Map> receiver_map_;
MaybeHandle<Code> maybe_handler_;
ExtraICState extra_ic_state_;
@@ -318,23 +273,6 @@
};
-// An IC_Utility encapsulates IC::UtilityId. It exists mainly because you
-// cannot make forward declarations to an enum.
-class IC_Utility {
- public:
- explicit IC_Utility(IC::UtilityId id)
- : address_(IC::AddressFromUtilityId(id)), id_(id) {}
-
- Address address() const { return address_; }
-
- IC::UtilityId id() const { return id_; }
-
- private:
- Address address_;
- IC::UtilityId id_;
-};
-
-
class CallIC : public IC {
public:
CallIC(Isolate* isolate, CallICNexus* nexus)
@@ -342,17 +280,13 @@
DCHECK(nexus != NULL);
}
- void PatchMegamorphic(Handle<Object> function);
-
- void HandleMiss(Handle<Object> receiver, Handle<Object> function);
-
- // Returns true if a custom handler was installed.
- bool DoCustomHandler(Handle<Object> receiver, Handle<Object> function,
- const CallICState& callic_state);
+ void HandleMiss(Handle<Object> function);
// Code generator routines.
static Handle<Code> initialize_stub(Isolate* isolate, int argc,
- CallICState::CallType call_type);
+ ConvertReceiverMode mode);
+ static Handle<Code> initialize_stub_in_optimized_code(
+ Isolate* isolate, int argc, ConvertReceiverMode mode);
static void Clear(Isolate* isolate, Code* host, CallICNexus* nexus);
};
@@ -360,53 +294,41 @@
class LoadIC : public IC {
public:
- static ExtraICState ComputeExtraICState(ContextualMode contextual_mode) {
- return LoadICState(contextual_mode).GetExtraICState();
+ static ExtraICState ComputeExtraICState(TypeofMode typeof_mode,
+ LanguageMode language_mode) {
+ return LoadICState(typeof_mode, language_mode).GetExtraICState();
}
- ContextualMode contextual_mode() const {
- return LoadICState::GetContextualMode(extra_ic_state());
+ TypeofMode typeof_mode() const {
+ return LoadICState::GetTypeofMode(extra_ic_state());
+ }
+
+ LanguageMode language_mode() const {
+ return LoadICState::GetLanguageMode(extra_ic_state());
}
LoadIC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus = NULL)
: IC(depth, isolate, nexus) {
- DCHECK(!FLAG_vector_ics || nexus != NULL);
+ DCHECK(nexus != NULL);
DCHECK(IsLoadStub());
}
- // TODO(mvstanton): The for_queries_only is because we have a case where we
- // construct an IC only to gather the contextual mode, and we don't have
- // vector/slot information. for_queries_only is a temporary hack to enable the
- // strong DCHECK protection around vector/slot.
- LoadIC(FrameDepth depth, Isolate* isolate, bool for_queries_only)
- : IC(depth, isolate, NULL, for_queries_only) {
- DCHECK(IsLoadStub());
- }
-
- // Returns if this IC is for contextual (no explicit receiver)
- // access to properties.
- bool IsUndeclaredGlobal(Handle<Object> receiver) {
- if (receiver->IsGlobalObject()) {
- return contextual_mode() == CONTEXTUAL;
- } else {
- DCHECK(contextual_mode() != CONTEXTUAL);
- return false;
- }
+ bool ShouldThrowReferenceError(Handle<Object> receiver) {
+ return receiver->IsJSGlobalObject() && typeof_mode() == NOT_INSIDE_TYPEOF;
}
// Code generator routines.
+
static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
- static void GeneratePreMonomorphic(MacroAssembler* masm) {
- GenerateMiss(masm);
- }
static void GenerateMiss(MacroAssembler* masm);
- static void GenerateNormal(MacroAssembler* masm);
- static void GenerateRuntimeGetProperty(MacroAssembler* masm);
+ static void GenerateRuntimeGetProperty(MacroAssembler* masm,
+ LanguageMode language_mode);
+ static void GenerateNormal(MacroAssembler* masm, LanguageMode language_mode);
static Handle<Code> initialize_stub(Isolate* isolate,
ExtraICState extra_state);
static Handle<Code> initialize_stub_in_optimized_code(
- Isolate* isolate, ExtraICState extra_state);
+ Isolate* isolate, ExtraICState extra_state, State initialization_state);
MUST_USE_RESULT MaybeHandle<Object> Load(Handle<Object> object,
Handle<Name> name);
@@ -418,32 +340,31 @@
Handle<Code> slow_stub() const {
if (kind() == Code::LOAD_IC) {
- return isolate()->builtins()->LoadIC_Slow();
+ return is_strong(language_mode())
+ ? isolate()->builtins()->LoadIC_Slow_Strong()
+ : isolate()->builtins()->LoadIC_Slow();
} else {
DCHECK_EQ(Code::KEYED_LOAD_IC, kind());
- return isolate()->builtins()->KeyedLoadIC_Slow();
+ return is_strong(language_mode())
+ ? isolate()->builtins()->KeyedLoadIC_Slow_Strong()
+ : isolate()->builtins()->KeyedLoadIC_Slow();
}
}
- Handle<Code> megamorphic_stub() OVERRIDE;
+ Handle<Code> megamorphic_stub() override;
// Update the inline cache and the global stub cache based on the
// lookup result.
void UpdateCaches(LookupIterator* lookup);
- virtual Handle<Code> CompileHandler(LookupIterator* lookup,
- Handle<Object> unused,
- CacheHolderFlag cache_holder) OVERRIDE;
+ Handle<Code> CompileHandler(LookupIterator* lookup, Handle<Object> unused,
+ CacheHolderFlag cache_holder) override;
private:
- virtual Handle<Code> pre_monomorphic_stub() const;
- static Handle<Code> pre_monomorphic_stub(Isolate* isolate,
- ExtraICState extra_state);
-
Handle<Code> SimpleFieldLoad(FieldIndex index);
static void Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool);
+ Address constant_pool);
friend class IC;
};
@@ -452,11 +373,13 @@
class KeyedLoadIC : public LoadIC {
public:
// ExtraICState bits (building on IC)
- class IcCheckTypeField : public BitField<IcCheckType, 1, 1> {};
+ class IcCheckTypeField
+ : public BitField<IcCheckType, LoadICState::kNextBitFieldOffset, 1> {};
- static ExtraICState ComputeExtraICState(ContextualMode contextual_mode,
+ static ExtraICState ComputeExtraICState(TypeofMode typeof_mode,
+ LanguageMode language_mode,
IcCheckType key_type) {
- return LoadICState(contextual_mode).GetExtraICState() |
+ return LoadICState(typeof_mode, language_mode).GetExtraICState() |
IcCheckTypeField::encode(key_type);
}
@@ -467,7 +390,7 @@
KeyedLoadIC(FrameDepth depth, Isolate* isolate,
KeyedLoadICNexus* nexus = NULL)
: LoadIC(depth, isolate, nexus) {
- DCHECK(!FLAG_vector_ics || nexus != NULL);
+ DCHECK(nexus != NULL);
DCHECK(target()->is_keyed_load_stub());
}
@@ -476,12 +399,11 @@
// Code generator routines.
static void GenerateMiss(MacroAssembler* masm);
- static void GenerateRuntimeGetProperty(MacroAssembler* masm);
+ static void GenerateRuntimeGetProperty(MacroAssembler* masm,
+ LanguageMode language_mode);
static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
- static void GeneratePreMonomorphic(MacroAssembler* masm) {
- GenerateMiss(masm);
- }
- static void GenerateGeneric(MacroAssembler* masm);
+ static void GenerateMegamorphic(MacroAssembler* masm,
+ LanguageMode language_mode);
// Bit mask to be tested against bit field for the cases when
// generic stub should go into slow case.
@@ -490,25 +412,22 @@
static const int kSlowCaseBitFieldMask =
(1 << Map::kIsAccessCheckNeeded) | (1 << Map::kHasIndexedInterceptor);
- static Handle<Code> initialize_stub(Isolate* isolate);
- static Handle<Code> initialize_stub_in_optimized_code(Isolate* isolate);
- static Handle<Code> generic_stub(Isolate* isolate);
- static Handle<Code> pre_monomorphic_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, ExtraICState extra_state);
+ static Handle<Code> ChooseMegamorphicStub(Isolate* isolate,
+ ExtraICState extra_state);
static void Clear(Isolate* isolate, Code* host, KeyedLoadICNexus* nexus);
protected:
// receiver is HeapObject because it could be a String or a JSObject
Handle<Code> LoadElementStub(Handle<HeapObject> receiver);
- virtual Handle<Code> pre_monomorphic_stub() const {
- return pre_monomorphic_stub(isolate());
- }
private:
- Handle<Code> generic_stub() const { return generic_stub(isolate()); }
-
static void Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool);
+ Address constant_pool);
friend class IC;
};
@@ -516,24 +435,17 @@
class StoreIC : public IC {
public:
- class StrictModeState : public BitField<StrictMode, 1, 1> {};
- static ExtraICState ComputeExtraICState(StrictMode flag) {
- return StrictModeState::encode(flag);
- }
- static StrictMode GetStrictMode(ExtraICState state) {
- return StrictModeState::decode(state);
+ static ExtraICState ComputeExtraICState(LanguageMode flag) {
+ return StoreICState(flag).GetExtraICState();
}
- // For convenience, a statically declared encoding of strict mode extra
- // IC state.
- static const ExtraICState kStrictModeState = 1 << StrictModeState::kShift;
-
- StoreIC(FrameDepth depth, Isolate* isolate) : IC(depth, isolate) {
+ StoreIC(FrameDepth depth, Isolate* isolate, FeedbackNexus* nexus = NULL)
+ : IC(depth, isolate, nexus) {
DCHECK(IsStoreStub());
}
- StrictMode strict_mode() const {
- return StrictModeState::decode(extra_ic_state());
+ LanguageMode language_mode() const {
+ return StoreICState::GetLanguageMode(extra_ic_state());
}
// Code generators for stub routines. Only called once at startup.
@@ -546,9 +458,13 @@
static void GenerateMegamorphic(MacroAssembler* masm);
static void GenerateNormal(MacroAssembler* masm);
static void GenerateRuntimeSetProperty(MacroAssembler* masm,
- StrictMode strict_mode);
+ LanguageMode language_mode);
- static Handle<Code> initialize_stub(Isolate* isolate, StrictMode strict_mode);
+ static Handle<Code> initialize_stub(Isolate* isolate,
+ LanguageMode language_mode,
+ State initialization_state);
+ static Handle<Code> initialize_stub_in_optimized_code(
+ Isolate* isolate, LanguageMode language_mode, State initialization_state);
MUST_USE_RESULT MaybeHandle<Object> Store(
Handle<Object> object, Handle<Name> name, Handle<Object> value,
@@ -558,34 +474,32 @@
bool LookupForWrite(LookupIterator* it, Handle<Object> value,
JSReceiver::StoreFromKeyed store_mode);
+ static void Clear(Isolate* isolate, Code* host, StoreICNexus* nexus);
+
protected:
- Handle<Code> megamorphic_stub() OVERRIDE;
-
// Stub accessors.
- Handle<Code> generic_stub() const;
-
+ Handle<Code> megamorphic_stub() override;
Handle<Code> slow_stub() const;
virtual Handle<Code> pre_monomorphic_stub() const {
- return pre_monomorphic_stub(isolate(), strict_mode());
+ return pre_monomorphic_stub(isolate(), language_mode());
}
static Handle<Code> pre_monomorphic_stub(Isolate* isolate,
- StrictMode strict_mode);
+ LanguageMode language_mode);
// Update the inline cache and the global stub cache based on the
// lookup result.
void UpdateCaches(LookupIterator* lookup, Handle<Object> value,
JSReceiver::StoreFromKeyed store_mode);
- virtual Handle<Code> CompileHandler(LookupIterator* lookup,
- Handle<Object> value,
- CacheHolderFlag cache_holder) OVERRIDE;
+ Handle<Code> CompileHandler(LookupIterator* lookup, Handle<Object> value,
+ CacheHolderFlag cache_holder) override;
private:
inline void set_target(Code* code);
static void Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool);
+ Address constant_pool);
friend class IC;
};
@@ -601,28 +515,27 @@
public:
// ExtraICState bits (building on IC)
// ExtraICState bits
+ // When more language modes are added, these BitFields need to move too.
+ STATIC_ASSERT(i::LANGUAGE_END == 3);
class ExtraICStateKeyedAccessStoreMode
- : public BitField<KeyedAccessStoreMode, 2, 4> {}; // NOLINT
+ : public BitField<KeyedAccessStoreMode, 3, 3> {}; // NOLINT
class IcCheckTypeField : public BitField<IcCheckType, 6, 1> {};
- static ExtraICState ComputeExtraICState(StrictMode flag,
+ static ExtraICState ComputeExtraICState(LanguageMode flag,
KeyedAccessStoreMode mode) {
- return StrictModeState::encode(flag) |
+ return StoreICState(flag).GetExtraICState() |
ExtraICStateKeyedAccessStoreMode::encode(mode) |
IcCheckTypeField::encode(ELEMENT);
}
- static KeyedAccessStoreMode GetKeyedAccessStoreMode(
- ExtraICState extra_state) {
- return ExtraICStateKeyedAccessStoreMode::decode(extra_state);
+ KeyedAccessStoreMode GetKeyedAccessStoreMode() {
+ return casted_nexus<KeyedStoreICNexus>()->GetKeyedAccessStoreMode();
}
- static IcCheckType GetKeyType(ExtraICState extra_state) {
- return IcCheckTypeField::decode(extra_state);
- }
-
- KeyedStoreIC(FrameDepth depth, Isolate* isolate) : StoreIC(depth, isolate) {
+ KeyedStoreIC(FrameDepth depth, Isolate* isolate,
+ KeyedStoreICNexus* nexus = NULL)
+ : StoreIC(depth, isolate, nexus) {
DCHECK(target()->is_keyed_store_stub());
}
@@ -637,39 +550,41 @@
}
static void GenerateMiss(MacroAssembler* masm);
static void GenerateSlow(MacroAssembler* masm);
- static void GenerateMegamorphic(MacroAssembler* masm, StrictMode strict_mode);
- static void GenerateGeneric(MacroAssembler* masm, StrictMode strict_mode);
- static void GenerateSloppyArguments(MacroAssembler* masm);
+ static void GenerateMegamorphic(MacroAssembler* masm,
+ LanguageMode language_mode);
+
+ static Handle<Code> initialize_stub(Isolate* isolate,
+ LanguageMode language_mode,
+ State initialization_state);
+
+ static Handle<Code> initialize_stub_in_optimized_code(
+ Isolate* isolate, LanguageMode language_mode, State initialization_state);
+ static Handle<Code> ChooseMegamorphicStub(Isolate* isolate,
+ ExtraICState extra_state);
+
+ static void Clear(Isolate* isolate, Code* host, KeyedStoreICNexus* nexus);
protected:
virtual Handle<Code> pre_monomorphic_stub() const {
- return pre_monomorphic_stub(isolate(), strict_mode());
+ return pre_monomorphic_stub(isolate(), language_mode());
}
static Handle<Code> pre_monomorphic_stub(Isolate* isolate,
- StrictMode strict_mode) {
- if (strict_mode == STRICT) {
+ LanguageMode language_mode) {
+ if (is_strict(language_mode)) {
return isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict();
} else {
return isolate->builtins()->KeyedStoreIC_PreMonomorphic();
}
}
- Handle<Code> StoreElementStub(Handle<JSObject> receiver,
+ Handle<Code> StoreElementStub(Handle<Map> receiver_map,
KeyedAccessStoreMode store_mode);
private:
inline void set_target(Code* code);
- // Stub accessors.
- Handle<Code> sloppy_arguments_stub() {
- return isolate()->builtins()->KeyedStoreIC_SloppyArguments();
- }
-
static void Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool);
-
- KeyedAccessStoreMode GetStoreMode(Handle<JSObject> receiver,
- Handle<Object> key, Handle<Object> value);
+ Address constant_pool);
Handle<Map> ComputeTransitionedMap(Handle<Map> map,
KeyedAccessStoreMode store_mode);
@@ -683,8 +598,6 @@
public:
explicit BinaryOpIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
- static Builtins::JavaScript TokenToJSBuiltin(Token::Value op);
-
MaybeHandle<Object> Transition(Handle<AllocationSite> allocation_site,
Handle<Object> left,
Handle<Object> right) WARN_UNUSED_RESULT;
@@ -703,7 +616,8 @@
static Condition ComputeCondition(Token::Value op);
// Factory method for getting an uninitialized compare stub.
- static Handle<Code> GetUninitialized(Isolate* isolate, Token::Value op);
+ static Handle<Code> GetUninitialized(Isolate* isolate, Token::Value op,
+ Strength strength);
private:
static bool HasInlinedSmiCode(Address address);
@@ -711,10 +625,11 @@
bool strict() const { return op_ == Token::EQ_STRICT; }
Condition GetCondition() const { return ComputeCondition(op_); }
- static Code* GetRawUninitialized(Isolate* isolate, Token::Value op);
+ static Code* GetRawUninitialized(Isolate* isolate, Token::Value op,
+ Strength strength);
static void Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool);
+ Address constant_pool);
Token::Value op_;
@@ -730,8 +645,7 @@
static Handle<Code> GetUninitialized();
- static void Clear(Address address, Code* target,
- ConstantPoolArray* constant_pool);
+ static void Clear(Address address, Code* target, Address constant_pool);
static Handle<Object> DoCompareNilSlow(Isolate* isolate, NilValue nil,
Handle<Object> object);
@@ -748,28 +662,10 @@
// Helper for BinaryOpIC and CompareIC.
enum InlinedSmiCheck { ENABLE_INLINED_SMI_CHECK, DISABLE_INLINED_SMI_CHECK };
-void PatchInlinedSmiCode(Address address, InlinedSmiCheck check);
+void PatchInlinedSmiCode(Isolate* isolate, Address address,
+ InlinedSmiCheck check);
-DECLARE_RUNTIME_FUNCTION(KeyedLoadIC_MissFromStubFailure);
-DECLARE_RUNTIME_FUNCTION(KeyedStoreIC_MissFromStubFailure);
-DECLARE_RUNTIME_FUNCTION(UnaryOpIC_Miss);
-DECLARE_RUNTIME_FUNCTION(StoreIC_MissFromStubFailure);
-DECLARE_RUNTIME_FUNCTION(ElementsTransitionAndStoreIC_Miss);
-DECLARE_RUNTIME_FUNCTION(BinaryOpIC_Miss);
-DECLARE_RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite);
-DECLARE_RUNTIME_FUNCTION(CompareNilIC_Miss);
-DECLARE_RUNTIME_FUNCTION(ToBooleanIC_Miss);
-DECLARE_RUNTIME_FUNCTION(LoadIC_MissFromStubFailure);
-
-// Support functions for callbacks handlers.
-DECLARE_RUNTIME_FUNCTION(StoreCallbackProperty);
-
-// Support functions for interceptor handlers.
-DECLARE_RUNTIME_FUNCTION(LoadPropertyWithInterceptorOnly);
-DECLARE_RUNTIME_FUNCTION(LoadPropertyWithInterceptor);
-DECLARE_RUNTIME_FUNCTION(LoadElementWithInterceptor);
-DECLARE_RUNTIME_FUNCTION(StorePropertyWithInterceptor);
-}
-} // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_IC_H_