Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(13)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/ic.h

Issue 483683005: Move IC code into a subdir and move ic-compilation related code from stub-cache into ic-compiler (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Fix BUILD.gn Created 6 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/ia32/stub-cache-ia32.cc ('k') | src/ic.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/ic.h
diff --git a/src/ic.h b/src/ic.h
deleted file mode 100644
index 8d41f803b4b0669bdf8dd988714bda11a5e774eb..0000000000000000000000000000000000000000
--- a/src/ic.h
+++ /dev/null
@@ -1,1033 +0,0 @@
-// 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_H_
-#define V8_IC_H_
-
-#include "src/macro-assembler.h"
-
-namespace v8 {
-namespace internal {
-
-
-const int kMaxKeyedPolymorphism = 4;
-
-
-// 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(SharedStoreIC_ExtendStorage) \
- 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;
-
- // The IC code is either invoked with no extra frames on the stack
- // or with a single extra frame for supporting calls.
- enum FrameDepth {
- NO_EXTRA_FRAME = 0,
- EXTRA_CALL_FRAME = 1
- };
-
- // Construct the IC structure with the given number of extra
- // JavaScript frames on the stack.
- IC(FrameDepth depth, Isolate* isolate);
- virtual ~IC() {}
-
- State state() const { return state_; }
- inline Address address() const;
-
- // Compute the current IC state based on the target stub, receiver and name.
- void UpdateState(Handle<Object> receiver, Handle<Object> name);
-
- bool IsNameCompatibleWithPrototypeFailure(Handle<Object> name);
- void MarkPrototypeFailure(Handle<Object> name) {
- DCHECK(IsNameCompatibleWithPrototypeFailure(name));
- state_ = PROTOTYPE_FAILURE;
- }
-
- // If the stub contains weak maps then this function adds the stub to
- // the dependent code array of each weak map.
- static void RegisterWeakMapDependency(Handle<Code> stub);
-
- // This function is called when a weak map in the stub is dying,
- // invalidates the stub by setting maps in it to undefined.
- static void InvalidateMaps(Code* stub);
-
- // Clear the inline cache to initial state.
- static void Clear(Isolate* isolate,
- Address address,
- ConstantPoolArray* constant_pool);
-
-#ifdef DEBUG
- bool IsLoadStub() const {
- return target()->is_load_stub() || target()->is_keyed_load_stub();
- }
-
- bool IsStoreStub() const {
- return target()->is_store_stub() || target()->is_keyed_store_stub();
- }
-
- 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,
- bool receiver_is_holder,
- Isolate* isolate,
- CacheHolderFlag* flag);
- static inline Handle<Map> GetICCacheHolder(HeapType* type, Isolate* isolate,
- CacheHolderFlag* flag);
-
- static bool IsCleared(Code* code) {
- InlineCacheState state = code->ic_state();
- return 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);
-
- protected:
- // Get the call-site target; used for determining the state.
- Handle<Code> target() const { return target_; }
-
- Address fp() const { return fp_; }
- Address pc() const { return *pc_address_; }
- Isolate* isolate() const { return isolate_; }
-
- // Get the shared function info of the caller.
- 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;
-
- // Set the call-site target.
- void set_target(Code* code) {
-#ifdef VERIFY_HEAP
- code->VerifyEmbeddedObjectsDependency();
-#endif
- SetTargetAtAddress(address(), code, constant_pool());
- target_set_ = true;
- }
-
- bool is_target_set() { return target_set_; }
-
- char TransitionMarkFromState(IC::State state);
- void TraceIC(const char* type, Handle<Object> name);
- 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);
-
- // Access the target code for the given IC address.
- static inline Code* GetTargetAtAddress(Address address,
- ConstantPoolArray* constant_pool);
- static inline void SetTargetAtAddress(Address address,
- Code* target,
- ConstantPoolArray* constant_pool);
- static void OnTypeFeedbackChanged(Isolate* isolate, Address address,
- State old_state, State new_state,
- bool target_remains_ic_stub);
- static void PostPatching(Address address, Code* target, Code* old_target);
-
- // Compute the handler either by compiling or by retrieving a cached version.
- Handle<Code> ComputeHandler(LookupIterator* lookup,
- Handle<Object> value = Handle<Code>::null());
- virtual Handle<Code> CompileHandler(LookupIterator* lookup,
- Handle<Object> value,
- CacheHolderFlag cache_holder) {
- UNREACHABLE();
- return Handle<Code>::null();
- }
-
- 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 CopyICToMegamorphicCache(Handle<Name> name);
- bool IsTransitionOfMonomorphicTarget(Map* source_map, Map* target_map);
- void PatchCache(Handle<Name> name, Handle<Code> code);
- Code::Kind kind() const { return kind_; }
- Code::Kind handler_kind() const {
- if (kind_ == Code::KEYED_LOAD_IC) return Code::LOAD_IC;
- DCHECK(kind_ == Code::LOAD_IC || kind_ == Code::STORE_IC ||
- kind_ == Code::KEYED_STORE_IC);
- return kind_;
- }
- virtual Handle<Code> megamorphic_stub() {
- UNREACHABLE();
- return Handle<Code>::null();
- }
-
- bool TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver,
- Handle<String> name);
-
- 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_);
- }
-
- void TargetMaps(MapHandleList* list) {
- FindTargetMaps();
- for (int i = 0; i < target_maps_.length(); i++) {
- list->Add(target_maps_.at(i));
- }
- }
-
- void TargetTypes(TypeHandleList* list) {
- FindTargetMaps();
- for (int i = 0; i < target_maps_.length(); i++) {
- list->Add(IC::MapToType<HeapType>(target_maps_.at(i), isolate_));
- }
- }
-
- Map* FirstTargetMap() {
- FindTargetMaps();
- return target_maps_.length() > 0 ? *target_maps_.at(0) : NULL;
- }
-
- protected:
- void UpdateTarget() {
- target_ = handle(raw_target(), isolate_);
- }
-
- private:
- Code* raw_target() const {
- return GetTargetAtAddress(address(), constant_pool());
- }
- inline ConstantPoolArray* constant_pool() const;
- inline ConstantPoolArray* raw_constant_pool() const;
-
- void FindTargetMaps() {
- if (target_maps_set_) return;
- target_maps_set_ = true;
- if (state_ == MONOMORPHIC) {
- Map* map = target_->FindFirstMap();
- if (map != NULL) target_maps_.Add(handle(map));
- } else if (state_ != UNINITIALIZED && state_ != PREMONOMORPHIC) {
- target_->FindAllMaps(&target_maps_);
- }
- }
-
- // 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
- // 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_;
-
- // The original code target that missed.
- Handle<Code> target_;
- bool target_set_;
- State state_;
- Code::Kind kind_;
- Handle<HeapType> receiver_type_;
- MaybeHandle<Code> maybe_handler_;
-
- ExtraICState extra_ic_state_;
- MapHandleList target_maps_;
- bool target_maps_set_;
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(IC);
-};
-
-
-// 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:
- enum CallType { METHOD, FUNCTION };
-
- class State V8_FINAL BASE_EMBEDDED {
- public:
- explicit State(ExtraICState extra_ic_state);
-
- State(int argc, CallType call_type)
- : argc_(argc), call_type_(call_type) {
- }
-
- ExtraICState GetExtraICState() const;
-
- static void GenerateAheadOfTime(
- Isolate*, void (*Generate)(Isolate*, const State&));
-
- int arg_count() const { return argc_; }
- CallType call_type() const { return call_type_; }
-
- bool CallAsMethod() const { return call_type_ == METHOD; }
-
- private:
- class ArgcBits: public BitField<int, 0, Code::kArgumentsBits> {};
- class CallTypeBits: public BitField<CallType, Code::kArgumentsBits, 1> {};
-
- const int argc_;
- const CallType call_type_;
- };
-
- explicit CallIC(Isolate* isolate)
- : IC(EXTRA_CALL_FRAME, isolate) {
- }
-
- void PatchMegamorphic(Handle<Object> function, Handle<FixedArray> vector,
- Handle<Smi> slot);
-
- void HandleMiss(Handle<Object> receiver,
- Handle<Object> function,
- Handle<FixedArray> vector,
- Handle<Smi> slot);
-
- // Returns true if a custom handler was installed.
- bool DoCustomHandler(Handle<Object> receiver,
- Handle<Object> function,
- Handle<FixedArray> vector,
- Handle<Smi> slot,
- const State& state);
-
- // Code generator routines.
- static Handle<Code> initialize_stub(Isolate* isolate,
- int argc,
- CallType call_type);
-
- static void Clear(Isolate* isolate, Address address, Code* target,
- ConstantPoolArray* constant_pool);
-
- private:
- inline IC::State FeedbackToState(Handle<FixedArray> vector,
- Handle<Smi> slot) const;
-};
-
-
-OStream& operator<<(OStream& os, const CallIC::State& s);
-
-
-class LoadIC: public IC {
- public:
- enum ParameterIndices {
- kReceiverIndex,
- kNameIndex,
- kParameterCount
- };
- static const Register ReceiverRegister();
- static const Register NameRegister();
-
- // With flag vector-ics, there is an additional argument. And for calls from
- // crankshaft, yet another.
- static const Register SlotRegister();
- static const Register VectorRegister();
-
- class State V8_FINAL BASE_EMBEDDED {
- public:
- explicit State(ExtraICState extra_ic_state)
- : state_(extra_ic_state) {}
-
- explicit State(ContextualMode mode)
- : state_(ContextualModeBits::encode(mode)) {}
-
- ExtraICState GetExtraICState() const { return state_; }
-
- ContextualMode contextual_mode() const {
- return ContextualModeBits::decode(state_);
- }
-
- private:
- class ContextualModeBits: public BitField<ContextualMode, 0, 1> {};
- STATIC_ASSERT(static_cast<int>(NOT_CONTEXTUAL) == 0);
-
- const ExtraICState state_;
- };
-
- static ExtraICState ComputeExtraICState(ContextualMode contextual_mode) {
- return State(contextual_mode).GetExtraICState();
- }
-
- static ContextualMode GetContextualMode(ExtraICState state) {
- return State(state).contextual_mode();
- }
-
- ContextualMode contextual_mode() const {
- return GetContextualMode(extra_ic_state());
- }
-
- explicit LoadIC(FrameDepth depth, Isolate* isolate)
- : IC(depth, isolate) {
- 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;
- }
- }
-
- // Code generator routines.
- static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
- static void GeneratePreMonomorphic(MacroAssembler* masm) {
- GenerateMiss(masm);
- }
- static void GenerateMiss(MacroAssembler* masm);
- static void GenerateMegamorphic(MacroAssembler* masm);
- static void GenerateNormal(MacroAssembler* masm);
- static void GenerateRuntimeGetProperty(MacroAssembler* masm);
-
- static Handle<Code> initialize_stub(Isolate* isolate,
- ExtraICState extra_state);
-
- MUST_USE_RESULT MaybeHandle<Object> Load(Handle<Object> object,
- Handle<Name> name);
-
- protected:
- void set_target(Code* code) {
- // The contextual mode must be preserved across IC patching.
- DCHECK(GetContextualMode(code->extra_ic_state()) ==
- GetContextualMode(target()->extra_ic_state()));
-
- IC::set_target(code);
- }
-
- Handle<Code> slow_stub() const {
- if (kind() == Code::LOAD_IC) {
- return isolate()->builtins()->LoadIC_Slow();
- } else {
- DCHECK_EQ(Code::KEYED_LOAD_IC, kind());
- return isolate()->builtins()->KeyedLoadIC_Slow();
- }
- }
-
- virtual Handle<Code> megamorphic_stub();
-
- // 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);
-
- 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);
-
- friend class IC;
-};
-
-
-class KeyedLoadIC: public LoadIC {
- public:
- explicit KeyedLoadIC(FrameDepth depth, Isolate* isolate)
- : LoadIC(depth, isolate) {
- DCHECK(target()->is_keyed_load_stub());
- }
-
- MUST_USE_RESULT MaybeHandle<Object> Load(Handle<Object> object,
- Handle<Object> key);
-
- // Code generator routines.
- static void GenerateMiss(MacroAssembler* masm);
- static void GenerateRuntimeGetProperty(MacroAssembler* masm);
- static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
- static void GeneratePreMonomorphic(MacroAssembler* masm) {
- GenerateMiss(masm);
- }
- static void GenerateGeneric(MacroAssembler* masm);
- static void GenerateString(MacroAssembler* masm);
- static void GenerateIndexedInterceptor(MacroAssembler* masm);
- static void GenerateSloppyArguments(MacroAssembler* masm);
-
- // Bit mask to be tested against bit field for the cases when
- // generic stub should go into slow case.
- // Access check is necessary explicitly since generic stub does not perform
- // map checks.
- static const int kSlowCaseBitFieldMask =
- (1 << Map::kIsAccessCheckNeeded) | (1 << Map::kHasIndexedInterceptor);
-
- static Handle<Code> generic_stub(Isolate* isolate);
- static Handle<Code> pre_monomorphic_stub(Isolate* isolate);
-
- protected:
- Handle<Code> LoadElementStub(Handle<JSObject> receiver);
- virtual Handle<Code> pre_monomorphic_stub() const {
- return pre_monomorphic_stub(isolate());
- }
-
- private:
- Handle<Code> generic_stub() const { return generic_stub(isolate()); }
- Handle<Code> indexed_interceptor_stub() {
- return isolate()->builtins()->KeyedLoadIC_IndexedInterceptor();
- }
- Handle<Code> sloppy_arguments_stub() {
- return isolate()->builtins()->KeyedLoadIC_SloppyArguments();
- }
- Handle<Code> string_stub() {
- return isolate()->builtins()->KeyedLoadIC_String();
- }
-
- static void Clear(Isolate* isolate,
- Address address,
- Code* target,
- ConstantPoolArray* constant_pool);
-
- friend class IC;
-};
-
-
-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);
- }
-
- // For convenience, a statically declared encoding of strict mode extra
- // IC state.
- static const ExtraICState kStrictModeState =
- 1 << StrictModeState::kShift;
-
- enum ParameterIndices {
- kReceiverIndex,
- kNameIndex,
- kValueIndex,
- kParameterCount
- };
- static const Register ReceiverRegister();
- static const Register NameRegister();
- static const Register ValueRegister();
-
- StoreIC(FrameDepth depth, Isolate* isolate)
- : IC(depth, isolate) {
- DCHECK(IsStoreStub());
- }
-
- StrictMode strict_mode() const {
- return StrictModeState::decode(extra_ic_state());
- }
-
- // Code generators for stub routines. Only called once at startup.
- static void GenerateSlow(MacroAssembler* masm);
- static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
- static void GeneratePreMonomorphic(MacroAssembler* masm) {
- GenerateMiss(masm);
- }
- static void GenerateMiss(MacroAssembler* masm);
- static void GenerateMegamorphic(MacroAssembler* masm);
- static void GenerateNormal(MacroAssembler* masm);
- static void GenerateRuntimeSetProperty(MacroAssembler* masm,
- StrictMode strict_mode);
-
- static Handle<Code> initialize_stub(Isolate* isolate,
- StrictMode strict_mode);
-
- MUST_USE_RESULT MaybeHandle<Object> Store(
- Handle<Object> object,
- Handle<Name> name,
- Handle<Object> value,
- JSReceiver::StoreFromKeyed store_mode =
- JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED);
-
- bool LookupForWrite(LookupIterator* it, Handle<Object> value,
- JSReceiver::StoreFromKeyed store_mode);
-
- protected:
- virtual Handle<Code> megamorphic_stub();
-
- // Stub accessors.
- virtual Handle<Code> generic_stub() const;
-
- virtual Handle<Code> slow_stub() const {
- return isolate()->builtins()->StoreIC_Slow();
- }
-
- virtual Handle<Code> pre_monomorphic_stub() const {
- return pre_monomorphic_stub(isolate(), strict_mode());
- }
-
- static Handle<Code> pre_monomorphic_stub(Isolate* isolate,
- StrictMode strict_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);
-
- private:
- void set_target(Code* code) {
- // Strict mode must be preserved across IC patching.
- DCHECK(GetStrictMode(code->extra_ic_state()) ==
- GetStrictMode(target()->extra_ic_state()));
- IC::set_target(code);
- }
-
- static void Clear(Isolate* isolate,
- Address address,
- Code* target,
- ConstantPoolArray* constant_pool);
-
- friend class IC;
-};
-
-
-enum KeyedStoreCheckMap {
- kDontCheckMap,
- kCheckMap
-};
-
-
-enum KeyedStoreIncrementLength {
- kDontIncrementLength,
- kIncrementLength
-};
-
-
-class KeyedStoreIC: public StoreIC {
- public:
- // ExtraICState bits (building on IC)
- // ExtraICState bits
- class ExtraICStateKeyedAccessStoreMode:
- public BitField<KeyedAccessStoreMode, 2, 4> {}; // NOLINT
-
- static ExtraICState ComputeExtraICState(StrictMode flag,
- KeyedAccessStoreMode mode) {
- return StrictModeState::encode(flag) |
- ExtraICStateKeyedAccessStoreMode::encode(mode);
- }
-
- static KeyedAccessStoreMode GetKeyedAccessStoreMode(
- ExtraICState extra_state) {
- return ExtraICStateKeyedAccessStoreMode::decode(extra_state);
- }
-
- // The map register isn't part of the normal call specification, but
- // ElementsTransitionAndStoreStub, used in polymorphic keyed store
- // stub implementations requires it to be initialized.
- static const Register MapRegister();
-
- KeyedStoreIC(FrameDepth depth, Isolate* isolate)
- : StoreIC(depth, isolate) {
- DCHECK(target()->is_keyed_store_stub());
- }
-
- MUST_USE_RESULT MaybeHandle<Object> Store(Handle<Object> object,
- Handle<Object> name,
- Handle<Object> value);
-
- // Code generators for stub routines. Only called once at startup.
- static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
- static void GeneratePreMonomorphic(MacroAssembler* masm) {
- GenerateMiss(masm);
- }
- static void GenerateMiss(MacroAssembler* masm);
- static void GenerateSlow(MacroAssembler* masm);
- static void GenerateRuntimeSetProperty(MacroAssembler* masm,
- StrictMode strict_mode);
- static void GenerateGeneric(MacroAssembler* masm, StrictMode strict_mode);
- static void GenerateSloppyArguments(MacroAssembler* masm);
-
- protected:
- virtual Handle<Code> pre_monomorphic_stub() const {
- return pre_monomorphic_stub(isolate(), strict_mode());
- }
- static Handle<Code> pre_monomorphic_stub(Isolate* isolate,
- StrictMode strict_mode) {
- if (strict_mode == STRICT) {
- return isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict();
- } else {
- return isolate->builtins()->KeyedStoreIC_PreMonomorphic();
- }
- }
- virtual Handle<Code> slow_stub() const {
- return isolate()->builtins()->KeyedStoreIC_Slow();
- }
- virtual Handle<Code> megamorphic_stub() {
- if (strict_mode() == STRICT) {
- return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
- } else {
- return isolate()->builtins()->KeyedStoreIC_Generic();
- }
- }
-
- Handle<Code> StoreElementStub(Handle<JSObject> receiver,
- KeyedAccessStoreMode store_mode);
-
- private:
- void set_target(Code* code) {
- // Strict mode must be preserved across IC patching.
- DCHECK(GetStrictMode(code->extra_ic_state()) == strict_mode());
- IC::set_target(code);
- }
-
- // Stub accessors.
- virtual Handle<Code> generic_stub() const {
- if (strict_mode() == STRICT) {
- return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
- } else {
- return isolate()->builtins()->KeyedStoreIC_Generic();
- }
- }
-
- 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);
-
- Handle<Map> ComputeTransitionedMap(Handle<Map> map,
- KeyedAccessStoreMode store_mode);
-
- friend class IC;
-};
-
-
-// Mode to overwrite BinaryExpression values.
-enum OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT };
-
-// Type Recording BinaryOpIC, that records the types of the inputs and outputs.
-class BinaryOpIC: public IC {
- public:
- class State V8_FINAL BASE_EMBEDDED {
- public:
- State(Isolate* isolate, ExtraICState extra_ic_state);
-
- State(Isolate* isolate, Token::Value op, OverwriteMode mode)
- : op_(op), mode_(mode), left_kind_(NONE), right_kind_(NONE),
- result_kind_(NONE), isolate_(isolate) {
- DCHECK_LE(FIRST_TOKEN, op);
- DCHECK_LE(op, LAST_TOKEN);
- }
-
- InlineCacheState GetICState() const {
- if (Max(left_kind_, right_kind_) == NONE) {
- return ::v8::internal::UNINITIALIZED;
- }
- if (Max(left_kind_, right_kind_) == GENERIC) {
- return ::v8::internal::MEGAMORPHIC;
- }
- if (Min(left_kind_, right_kind_) == GENERIC) {
- return ::v8::internal::GENERIC;
- }
- return ::v8::internal::MONOMORPHIC;
- }
-
- ExtraICState GetExtraICState() const;
-
- static void GenerateAheadOfTime(
- Isolate*, void (*Generate)(Isolate*, const State&));
-
- bool CanReuseDoubleBox() const {
- return (result_kind_ > SMI && result_kind_ <= NUMBER) &&
- ((mode_ == OVERWRITE_LEFT &&
- left_kind_ > SMI && left_kind_ <= NUMBER) ||
- (mode_ == OVERWRITE_RIGHT &&
- right_kind_ > SMI && right_kind_ <= NUMBER));
- }
-
- // Returns true if the IC _could_ create allocation mementos.
- bool CouldCreateAllocationMementos() const {
- if (left_kind_ == STRING || right_kind_ == STRING) {
- DCHECK_EQ(Token::ADD, op_);
- return true;
- }
- return false;
- }
-
- // Returns true if the IC _should_ create allocation mementos.
- bool ShouldCreateAllocationMementos() const {
- return FLAG_allocation_site_pretenuring &&
- CouldCreateAllocationMementos();
- }
-
- bool HasSideEffects() const {
- return Max(left_kind_, right_kind_) == GENERIC;
- }
-
- // Returns true if the IC should enable the inline smi code (i.e. if either
- // parameter may be a smi).
- bool UseInlinedSmiCode() const {
- return KindMaybeSmi(left_kind_) || KindMaybeSmi(right_kind_);
- }
-
- static const int FIRST_TOKEN = Token::BIT_OR;
- static const int LAST_TOKEN = Token::MOD;
-
- Token::Value op() const { return op_; }
- OverwriteMode mode() const { return mode_; }
- Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
-
- Type* GetLeftType(Zone* zone) const {
- return KindToType(left_kind_, zone);
- }
- Type* GetRightType(Zone* zone) const {
- return KindToType(right_kind_, zone);
- }
- Type* GetResultType(Zone* zone) const;
-
- void Update(Handle<Object> left,
- Handle<Object> right,
- Handle<Object> result);
-
- Isolate* isolate() const { return isolate_; }
-
- private:
- friend OStream& operator<<(OStream& os, const BinaryOpIC::State& s);
-
- enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
-
- Kind UpdateKind(Handle<Object> object, Kind kind) const;
-
- static const char* KindToString(Kind kind);
- static Type* KindToType(Kind kind, Zone* zone);
- static bool KindMaybeSmi(Kind kind) {
- return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
- }
-
- // We truncate the last bit of the token.
- STATIC_ASSERT(LAST_TOKEN - FIRST_TOKEN < (1 << 4));
- class OpField: public BitField<int, 0, 4> {};
- class OverwriteModeField: public BitField<OverwriteMode, 4, 2> {};
- class ResultKindField: public BitField<Kind, 6, 3> {};
- class LeftKindField: public BitField<Kind, 9, 3> {};
- // When fixed right arg is set, we don't need to store the right kind.
- // Thus the two fields can overlap.
- class HasFixedRightArgField: public BitField<bool, 12, 1> {};
- class FixedRightArgValueField: public BitField<int, 13, 4> {};
- class RightKindField: public BitField<Kind, 13, 3> {};
-
- Token::Value op_;
- OverwriteMode mode_;
- Kind left_kind_;
- Kind right_kind_;
- Kind result_kind_;
- Maybe<int> fixed_right_arg_;
- Isolate* isolate_;
- };
-
- 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) V8_WARN_UNUSED_RESULT;
-};
-
-
-OStream& operator<<(OStream& os, const BinaryOpIC::State& s);
-
-
-class CompareIC: public IC {
- public:
- // The type/state lattice is defined by the following inequations:
- // UNINITIALIZED < ...
- // ... < GENERIC
- // SMI < NUMBER
- // INTERNALIZED_STRING < STRING
- // KNOWN_OBJECT < OBJECT
- enum State {
- UNINITIALIZED,
- SMI,
- NUMBER,
- STRING,
- INTERNALIZED_STRING,
- UNIQUE_NAME, // Symbol or InternalizedString
- OBJECT, // JSObject
- KNOWN_OBJECT, // JSObject with specific map (faster check)
- GENERIC
- };
-
- static State NewInputState(State old_state, Handle<Object> value);
-
- static Type* StateToType(Zone* zone,
- State state,
- Handle<Map> map = Handle<Map>());
-
- static void StubInfoToType(uint32_t stub_key, Type** left_type,
- Type** right_type, Type** overall_type,
- Handle<Map> map, Zone* zone);
-
- CompareIC(Isolate* isolate, Token::Value op)
- : IC(EXTRA_CALL_FRAME, isolate), op_(op) { }
-
- // Update the inline cache for the given operands.
- Code* UpdateCaches(Handle<Object> x, Handle<Object> y);
-
-
- // Factory method for getting an uninitialized compare stub.
- static Handle<Code> GetUninitialized(Isolate* isolate, Token::Value op);
-
- // Helper function for computing the condition for a compare operation.
- static Condition ComputeCondition(Token::Value op);
-
- static const char* GetStateName(State state);
-
- private:
- static bool HasInlinedSmiCode(Address address);
-
- State TargetState(State old_state,
- State old_left,
- State old_right,
- bool has_inlined_smi_code,
- Handle<Object> x,
- Handle<Object> y);
-
- bool strict() const { return op_ == Token::EQ_STRICT; }
- Condition GetCondition() const { return ComputeCondition(op_); }
-
- static Code* GetRawUninitialized(Isolate* isolate, Token::Value op);
-
- static void Clear(Isolate* isolate,
- Address address,
- Code* target,
- ConstantPoolArray* constant_pool);
-
- Token::Value op_;
-
- friend class IC;
-};
-
-
-class CompareNilIC: public IC {
- public:
- explicit CompareNilIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
-
- Handle<Object> CompareNil(Handle<Object> object);
-
- static Handle<Code> GetUninitialized();
-
- static void Clear(Address address,
- Code* target,
- ConstantPoolArray* constant_pool);
-
- static Handle<Object> DoCompareNilSlow(Isolate* isolate, NilValue nil,
- Handle<Object> object);
-};
-
-
-class ToBooleanIC: public IC {
- public:
- explicit ToBooleanIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) { }
-
- Handle<Object> ToBoolean(Handle<Object> object);
-};
-
-
-// Helper for BinaryOpIC and CompareIC.
-enum InlinedSmiCheck { ENABLE_INLINED_SMI_CHECK, DISABLE_INLINED_SMI_CHECK };
-void PatchInlinedSmiCode(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);
-
-
-} } // namespace v8::internal
-
-#endif // V8_IC_H_
« no previous file with comments | « src/ia32/stub-cache-ia32.cc ('k') | src/ic.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698