blob: 367a9aff520beff9928f45ec9aca942886b2acad [file] [log] [blame]
// Copyright 2016 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_ACCESSOR_ASSEMBLER_H_
#define V8_IC_ACCESSOR_ASSEMBLER_H_
#include "src/base/optional.h"
#include "src/codegen/code-stub-assembler.h"
#include "src/compiler/code-assembler.h"
namespace v8 {
namespace internal {
namespace compiler {
class CodeAssemblerState;
} // namespace compiler
class ExitPoint;
class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
public:
explicit AccessorAssembler(compiler::CodeAssemblerState* state)
: CodeStubAssembler(state) {}
void GenerateLoadIC();
void GenerateLoadIC_Megamorphic();
void GenerateLoadIC_Noninlined();
void GenerateLoadIC_NoFeedback();
void GenerateLoadGlobalIC_NoFeedback();
void GenerateLoadICTrampoline();
void GenerateLoadICBaseline();
void GenerateLoadICTrampoline_Megamorphic();
void GenerateLoadSuperIC();
void GenerateLoadSuperICBaseline();
void GenerateKeyedLoadIC();
void GenerateKeyedLoadIC_Megamorphic();
void GenerateKeyedLoadIC_MegamorphicStringKey();
void GenerateKeyedLoadIC_PolymorphicName();
void GenerateKeyedLoadICTrampoline();
void GenerateKeyedLoadICBaseline();
void GenerateKeyedLoadICTrampoline_Megamorphic();
void GenerateKeyedLoadICTrampoline_MegamorphicStringKey();
void GenerateStoreIC();
void GenerateStoreICTrampoline();
void GenerateStoreICBaseline();
void GenerateDefineNamedOwnIC();
void GenerateDefineNamedOwnICTrampoline();
void GenerateDefineNamedOwnICBaseline();
void GenerateStoreGlobalIC();
void GenerateStoreGlobalICTrampoline();
void GenerateStoreGlobalICBaseline();
void GenerateCloneObjectIC();
void GenerateCloneObjectICBaseline();
void GenerateCloneObjectIC_Slow();
void GenerateKeyedHasIC();
void GenerateKeyedHasICBaseline();
void GenerateKeyedHasIC_Megamorphic();
void GenerateKeyedHasIC_PolymorphicName();
void GenerateLoadGlobalIC(TypeofMode typeof_mode);
void GenerateLoadGlobalICTrampoline(TypeofMode typeof_mode);
void GenerateLoadGlobalICBaseline(TypeofMode typeof_mode);
void GenerateLookupGlobalIC(TypeofMode typeof_mode);
void GenerateLookupGlobalICTrampoline(TypeofMode typeof_mode);
void GenerateLookupGlobalICBaseline(TypeofMode typeof_mode);
void GenerateLookupContextTrampoline(TypeofMode typeof_mode);
void GenerateLookupContextBaseline(TypeofMode typeof_mode);
void GenerateKeyedStoreIC();
void GenerateKeyedStoreICTrampoline();
void GenerateKeyedStoreICBaseline();
void GenerateDefineKeyedOwnIC();
void GenerateDefineKeyedOwnICTrampoline();
void GenerateDefineKeyedOwnICBaseline();
void GenerateStoreInArrayLiteralIC();
void GenerateStoreInArrayLiteralICBaseline();
void TryProbeStubCache(StubCache* stub_cache,
TNode<Object> lookup_start_object, TNode<Name> name,
Label* if_handler, TVariable<MaybeObject>* var_handler,
Label* if_miss);
TNode<IntPtrT> StubCachePrimaryOffsetForTesting(TNode<Name> name,
TNode<Map> map) {
return StubCachePrimaryOffset(name, map);
}
TNode<IntPtrT> StubCacheSecondaryOffsetForTesting(TNode<Name> name,
TNode<Map> map) {
return StubCacheSecondaryOffset(name, map);
}
struct LoadICParameters {
LoadICParameters(
TNode<Context> context, TNode<Object> receiver, TNode<Object> name,
TNode<TaggedIndex> slot, TNode<HeapObject> vector,
base::Optional<TNode<Object>> lookup_start_object = base::nullopt)
: context_(context),
receiver_(receiver),
name_(name),
slot_(slot),
vector_(vector),
lookup_start_object_(lookup_start_object ? lookup_start_object.value()
: receiver) {}
LoadICParameters(const LoadICParameters* p, TNode<Object> unique_name)
: context_(p->context_),
receiver_(p->receiver_),
name_(unique_name),
slot_(p->slot_),
vector_(p->vector_),
lookup_start_object_(p->lookup_start_object_) {}
TNode<Context> context() const { return context_; }
TNode<Object> receiver() const { return receiver_; }
TNode<Object> name() const { return name_; }
TNode<TaggedIndex> slot() const { return slot_; }
TNode<HeapObject> vector() const { return vector_; }
TNode<Object> lookup_start_object() const {
return lookup_start_object_.value();
}
// Usable in cases where the receiver and the lookup start object are
// expected to be the same, i.e., when "receiver != lookup_start_object"
// case is not supported or not expected by the surrounding code.
TNode<Object> receiver_and_lookup_start_object() const {
DCHECK_EQ(receiver_, lookup_start_object_);
return receiver_;
}
private:
TNode<Context> context_;
TNode<Object> receiver_;
TNode<Object> name_;
TNode<TaggedIndex> slot_;
TNode<HeapObject> vector_;
base::Optional<TNode<Object>> lookup_start_object_;
};
struct LazyLoadICParameters {
LazyLoadICParameters(
LazyNode<Context> context, TNode<Object> receiver,
LazyNode<Object> name, LazyNode<TaggedIndex> slot,
TNode<HeapObject> vector,
base::Optional<TNode<Object>> lookup_start_object = base::nullopt)
: context_(context),
receiver_(receiver),
name_(name),
slot_(slot),
vector_(vector),
lookup_start_object_(lookup_start_object ? lookup_start_object.value()
: receiver) {}
explicit LazyLoadICParameters(const LoadICParameters* p)
: receiver_(p->receiver()),
vector_(p->vector()),
lookup_start_object_(p->lookup_start_object()) {
slot_ = [=] { return p->slot(); };
context_ = [=] { return p->context(); };
name_ = [=] { return p->name(); };
}
TNode<Context> context() const { return context_(); }
TNode<Object> receiver() const { return receiver_; }
TNode<Object> name() const { return name_(); }
TNode<TaggedIndex> slot() const { return slot_(); }
TNode<HeapObject> vector() const { return vector_; }
TNode<Object> lookup_start_object() const { return lookup_start_object_; }
// Usable in cases where the receiver and the lookup start object are
// expected to be the same, i.e., when "receiver != lookup_start_object"
// case is not supported or not expected by the surrounding code.
TNode<Object> receiver_and_lookup_start_object() const {
DCHECK_EQ(receiver_, lookup_start_object_);
return receiver_;
}
private:
LazyNode<Context> context_;
TNode<Object> receiver_;
LazyNode<Object> name_;
LazyNode<TaggedIndex> slot_;
TNode<HeapObject> vector_;
TNode<Object> lookup_start_object_;
};
void LoadGlobalIC(TNode<HeapObject> maybe_feedback_vector,
const LazyNode<TaggedIndex>& lazy_slot,
const LazyNode<Context>& lazy_context,
const LazyNode<Name>& lazy_name, TypeofMode typeof_mode,
ExitPoint* exit_point);
// Specialized LoadIC for inlined bytecode handler, hand-tuned to omit frame
// construction on common paths.
void LoadIC_BytecodeHandler(const LazyLoadICParameters* p,
ExitPoint* exit_point);
// Loads dataX field from the DataHandler object.
TNode<MaybeObject> LoadHandlerDataField(TNode<DataHandler> handler,
int data_index);
protected:
enum class StoreICMode {
// TODO(v8:12548): rename to kDefineKeyedOwnInLiteral
kDefault,
kDefineNamedOwn,
kDefineKeyedOwn,
};
struct StoreICParameters {
StoreICParameters(TNode<Context> context,
base::Optional<TNode<Object>> receiver,
TNode<Object> name, TNode<Object> value,
base::Optional<TNode<Smi>> flags, TNode<TaggedIndex> slot,
TNode<HeapObject> vector, StoreICMode mode)
: context_(context),
receiver_(receiver),
name_(name),
value_(value),
flags_(flags),
slot_(slot),
vector_(vector),
mode_(mode) {}
TNode<Context> context() const { return context_; }
TNode<Object> receiver() const { return receiver_.value(); }
TNode<Object> name() const { return name_; }
TNode<Object> value() const { return value_; }
TNode<Smi> flags() const { return flags_.value(); }
TNode<TaggedIndex> slot() const { return slot_; }
TNode<HeapObject> vector() const { return vector_; }
TNode<Object> lookup_start_object() const { return receiver(); }
bool receiver_is_null() const { return !receiver_.has_value(); }
bool flags_is_null() const { return !flags_.has_value(); }
bool IsDefineNamedOwn() const {
return mode_ == StoreICMode::kDefineNamedOwn;
}
bool IsDefineKeyedOwn() const {
return mode_ == StoreICMode::kDefineKeyedOwn;
}
bool IsAnyDefineOwn() const {
return IsDefineNamedOwn() || IsDefineKeyedOwn();
}
private:
TNode<Context> context_;
base::Optional<TNode<Object>> receiver_;
TNode<Object> name_;
TNode<Object> value_;
base::Optional<TNode<Smi>> flags_;
TNode<TaggedIndex> slot_;
TNode<HeapObject> vector_;
StoreICMode mode_;
};
enum class LoadAccessMode { kLoad, kHas };
enum class ICMode { kNonGlobalIC, kGlobalIC };
enum ElementSupport { kOnlyProperties, kSupportElements };
void HandleStoreICHandlerCase(
const StoreICParameters* p, TNode<MaybeObject> handler, Label* miss,
ICMode ic_mode, ElementSupport support_elements = kOnlyProperties);
enum StoreTransitionMapFlags {
kDontCheckPrototypeValidity = 0,
kCheckPrototypeValidity = 1 << 0,
kValidateTransitionHandler = 1 << 1,
kStoreTransitionMapFlagsMask =
kCheckPrototypeValidity | kValidateTransitionHandler,
};
void HandleStoreICTransitionMapHandlerCase(const StoreICParameters* p,
TNode<Map> transition_map,
Label* miss,
StoreTransitionMapFlags flags);
// Updates flags on |dict| if |name| is an interesting symbol.
void UpdateMayHaveInterestingSymbol(TNode<PropertyDictionary> dict,
TNode<Name> name);
void JumpIfDataProperty(TNode<Uint32T> details, Label* writable,
Label* readonly);
void InvalidateValidityCellIfPrototype(
TNode<Map> map, base::Optional<TNode<Uint32T>> bitfield3 = base::nullopt);
void OverwriteExistingFastDataProperty(TNode<HeapObject> object,
TNode<Map> object_map,
TNode<DescriptorArray> descriptors,
TNode<IntPtrT> descriptor_name_index,
TNode<Uint32T> details,
TNode<Object> value, Label* slow,
bool do_transitioning_store);
void StoreJSSharedStructField(TNode<Context> context,
TNode<HeapObject> shared_struct,
TNode<Map> shared_struct_map,
TNode<DescriptorArray> descriptors,
TNode<IntPtrT> descriptor_name_index,
TNode<Uint32T> details, TNode<Object> value);
TNode<BoolT> IsPropertyDetailsConst(TNode<Uint32T> details);
void CheckFieldType(TNode<DescriptorArray> descriptors,
TNode<IntPtrT> name_index, TNode<Word32T> representation,
TNode<Object> value, Label* bailout);
private:
// Stub generation entry points.
// LoadIC contains the full LoadIC logic, while LoadIC_Noninlined contains
// logic not inlined into Ignition bytecode handlers.
void LoadIC(const LoadICParameters* p);
// Can be used in the receiver != lookup_start_object case.
void LoadIC_Noninlined(const LoadICParameters* p,
TNode<Map> lookup_start_object_map,
TNode<HeapObject> feedback,
TVariable<MaybeObject>* var_handler, Label* if_handler,
Label* miss, ExitPoint* exit_point);
void LoadSuperIC(const LoadICParameters* p);
TNode<Object> LoadDescriptorValue(TNode<Map> map,
TNode<IntPtrT> descriptor_entry);
TNode<MaybeObject> LoadDescriptorValueOrFieldType(
TNode<Map> map, TNode<IntPtrT> descriptor_entry);
void LoadIC_NoFeedback(const LoadICParameters* p, TNode<Smi> smi_typeof_mode);
void LoadSuperIC_NoFeedback(const LoadICParameters* p);
void LoadGlobalIC_NoFeedback(TNode<Context> context, TNode<Object> name,
TNode<Smi> smi_typeof_mode);
void KeyedLoadIC(const LoadICParameters* p, LoadAccessMode access_mode);
void KeyedLoadICGeneric(const LoadICParameters* p);
void KeyedLoadICGeneric_StringKey(const LoadICParameters* p);
void KeyedLoadICPolymorphicName(const LoadICParameters* p,
LoadAccessMode access_mode);
void StoreIC(const StoreICParameters* p);
void StoreGlobalIC(const StoreICParameters* p);
void StoreGlobalIC_PropertyCellCase(TNode<PropertyCell> property_cell,
TNode<Object> value,
ExitPoint* exit_point, Label* miss);
void KeyedStoreIC(const StoreICParameters* p);
void DefineKeyedOwnIC(const StoreICParameters* p);
void StoreInArrayLiteralIC(const StoreICParameters* p);
void LookupGlobalIC(LazyNode<Object> lazy_name, TNode<TaggedIndex> depth,
LazyNode<TaggedIndex> lazy_slot, TNode<Context> context,
LazyNode<FeedbackVector> lazy_feedback_vector,
TypeofMode typeof_mode);
void LookupContext(LazyNode<Object> lazy_name, TNode<TaggedIndex> depth,
LazyNode<TaggedIndex> lazy_slot, TNode<Context> context,
TypeofMode typeof_mode);
void GotoIfNotSameNumberBitPattern(TNode<Float64T> left,
TNode<Float64T> right, Label* miss);
// IC dispatcher behavior.
// Checks monomorphic case. Returns {feedback} entry of the vector.
TNode<HeapObjectReference> TryMonomorphicCase(
TNode<TaggedIndex> slot, TNode<FeedbackVector> vector,
TNode<HeapObjectReference> weak_lookup_start_object_map,
Label* if_handler, TVariable<MaybeObject>* var_handler, Label* if_miss);
void HandlePolymorphicCase(
TNode<HeapObjectReference> weak_lookup_start_object_map,
TNode<WeakFixedArray> feedback, Label* if_handler,
TVariable<MaybeObject>* var_handler, Label* if_miss);
void TryMegaDOMCase(TNode<Object> lookup_start_object,
TNode<Map> lookup_start_object_map,
TVariable<MaybeObject>* var_handler, TNode<Object> vector,
TNode<TaggedIndex> slot, Label* miss,
ExitPoint* exit_point);
// LoadIC implementation.
void HandleLoadICHandlerCase(
const LazyLoadICParameters* p, TNode<MaybeObject> handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode = ICMode::kNonGlobalIC,
OnNonExistent on_nonexistent = OnNonExistent::kReturnUndefined,
ElementSupport support_elements = kOnlyProperties,
LoadAccessMode access_mode = LoadAccessMode::kLoad);
void HandleLoadICSmiHandlerCase(const LazyLoadICParameters* p,
TNode<Object> holder, TNode<Smi> smi_handler,
TNode<MaybeObject> handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode,
OnNonExistent on_nonexistent,
ElementSupport support_elements,
LoadAccessMode access_mode);
void HandleLoadICProtoHandler(const LazyLoadICParameters* p,
TNode<DataHandler> handler,
TVariable<Object>* var_holder,
TVariable<MaybeObject>* var_smi_handler,
Label* if_smi_handler, Label* miss,
ExitPoint* exit_point, ICMode ic_mode,
LoadAccessMode access_mode);
void HandleLoadCallbackProperty(const LazyLoadICParameters* p,
TNode<JSObject> holder,
TNode<Word32T> handler_word,
ExitPoint* exit_point);
void HandleLoadAccessor(const LazyLoadICParameters* p,
TNode<CallHandlerInfo> call_handler_info,
TNode<Word32T> handler_word,
TNode<DataHandler> handler,
TNode<Uint32T> handler_kind, ExitPoint* exit_point);
void HandleLoadField(TNode<JSObject> holder, TNode<Word32T> handler_word,
TVariable<Float64T>* var_double_value,
Label* rebox_double, Label* miss, ExitPoint* exit_point);
#if V8_ENABLE_WEBASSEMBLY
void HandleLoadWasmField(TNode<WasmObject> holder,
TNode<Int32T> wasm_value_type,
TNode<IntPtrT> field_offset,
TVariable<Float64T>* var_double_value,
Label* rebox_double, ExitPoint* exit_point);
void HandleLoadWasmField(TNode<WasmObject> holder,
TNode<Word32T> handler_word,
TVariable<Float64T>* var_double_value,
Label* rebox_double, ExitPoint* exit_point);
#endif // V8_ENABLE_WEBASSEMBLY
void EmitAccessCheck(TNode<Context> expected_native_context,
TNode<Context> context, TNode<Object> receiver,
Label* can_access, Label* miss);
void HandleLoadICSmiHandlerLoadNamedCase(
const LazyLoadICParameters* p, TNode<Object> holder,
TNode<Uint32T> handler_kind, TNode<Word32T> handler_word,
Label* rebox_double, TVariable<Float64T>* var_double_value,
TNode<MaybeObject> handler, Label* miss, ExitPoint* exit_point,
ICMode ic_mode, OnNonExistent on_nonexistent,
ElementSupport support_elements);
void HandleLoadICSmiHandlerHasNamedCase(const LazyLoadICParameters* p,
TNode<Object> holder,
TNode<Uint32T> handler_kind,
Label* miss, ExitPoint* exit_point,
ICMode ic_mode);
// LoadGlobalIC implementation.
void LoadGlobalIC_TryPropertyCellCase(TNode<FeedbackVector> vector,
TNode<TaggedIndex> slot,
const LazyNode<Context>& lazy_context,
ExitPoint* exit_point,
Label* try_handler, Label* miss);
void LoadGlobalIC_TryHandlerCase(TNode<FeedbackVector> vector,
TNode<TaggedIndex> slot,
const LazyNode<Context>& lazy_context,
const LazyNode<Name>& lazy_name,
TypeofMode typeof_mode,
ExitPoint* exit_point, Label* miss);
// This is a copy of ScriptContextTable::Lookup. They should be kept in sync.
void ScriptContextTableLookup(TNode<Name> name,
TNode<NativeContext> native_context,
Label* found_hole, Label* not_found);
// StoreIC implementation.
void HandleStoreICProtoHandler(const StoreICParameters* p,
TNode<StoreHandler> handler, Label* miss,
ICMode ic_mode,
ElementSupport support_elements);
void HandleStoreICSmiHandlerCase(TNode<Word32T> handler_word,
TNode<JSObject> holder, TNode<Object> value,
Label* miss);
void HandleStoreICSmiHandlerJSSharedStructFieldCase(
TNode<Context> context, TNode<Word32T> handler_word,
TNode<JSObject> holder, TNode<Object> value);
void HandleStoreFieldAndReturn(TNode<Word32T> handler_word,
TNode<JSObject> holder, TNode<Object> value,
base::Optional<TNode<Float64T>> double_value,
Representation representation, Label* miss);
void CheckPrototypeValidityCell(TNode<Object> maybe_validity_cell,
Label* miss);
void HandleStoreICNativeDataProperty(const StoreICParameters* p,
TNode<HeapObject> holder,
TNode<Word32T> handler_word);
void HandleStoreToProxy(const StoreICParameters* p, TNode<JSProxy> proxy,
Label* miss, ElementSupport support_elements);
void HandleStoreAccessor(const StoreICParameters* p, TNode<HeapObject> holder,
TNode<Word32T> handler_word);
// KeyedLoadIC_Generic implementation.
void GenericElementLoad(TNode<HeapObject> lookup_start_object,
TNode<Map> lookup_start_object_map,
TNode<Int32T> lookup_start_object_instance_type,
TNode<IntPtrT> index, Label* slow);
enum UseStubCache { kUseStubCache, kDontUseStubCache };
void GenericPropertyLoad(TNode<HeapObject> lookup_start_object,
TNode<Map> lookup_start_object_map,
TNode<Int32T> lookup_start_object_instance_type,
const LoadICParameters* p, Label* slow,
UseStubCache use_stub_cache = kUseStubCache);
// Low-level helpers.
using OnCodeHandler = std::function<void(TNode<Code> code_handler)>;
using OnFoundOnLookupStartObject = std::function<void(
TNode<PropertyDictionary> properties, TNode<IntPtrT> name_index)>;
template <typename ICHandler, typename ICParameters>
TNode<Object> HandleProtoHandler(
const ICParameters* p, TNode<DataHandler> handler,
const OnCodeHandler& on_code_handler,
const OnFoundOnLookupStartObject& on_found_on_lookup_start_object,
Label* miss, ICMode ic_mode);
void CheckHeapObjectTypeMatchesDescriptor(TNode<Word32T> handler_word,
TNode<JSObject> holder,
TNode<Object> value,
Label* bailout);
// Double fields store double values in a mutable box, where stores are
// writes into this box rather than HeapNumber assignment.
void CheckDescriptorConsidersNumbersMutable(TNode<Word32T> handler_word,
TNode<JSObject> holder,
Label* bailout);
// Extends properties backing store by JSObject::kFieldsAdded elements,
// returns updated properties backing store.
TNode<PropertyArray> ExtendPropertiesBackingStore(TNode<HeapObject> object,
TNode<IntPtrT> index);
void EmitFastElementsBoundsCheck(TNode<JSObject> object,
TNode<FixedArrayBase> elements,
TNode<IntPtrT> intptr_index,
TNode<BoolT> is_jsarray_condition,
Label* miss);
void EmitElementLoad(TNode<HeapObject> object, TNode<Word32T> elements_kind,
TNode<IntPtrT> key, TNode<BoolT> is_jsarray_condition,
Label* if_hole, Label* rebox_double,
TVariable<Float64T>* var_double_value,
Label* unimplemented_elements_kind, Label* out_of_bounds,
Label* miss, ExitPoint* exit_point,
LoadAccessMode access_mode = LoadAccessMode::kLoad);
// Stub cache access helpers.
// This enum is used here as a replacement for StubCache::Table to avoid
// including stub cache header.
enum StubCacheTable : int;
TNode<IntPtrT> StubCachePrimaryOffset(TNode<Name> name, TNode<Map> map);
TNode<IntPtrT> StubCacheSecondaryOffset(TNode<Name> name, TNode<Map> map);
void TryProbeStubCacheTable(StubCache* stub_cache, StubCacheTable table_id,
TNode<IntPtrT> entry_offset, TNode<Object> name,
TNode<Map> map, Label* if_handler,
TVariable<MaybeObject>* var_handler,
Label* if_miss);
void BranchIfPrototypesHaveNoElements(TNode<Map> receiver_map,
Label* definitely_no_elements,
Label* possibly_elements);
};
// Abstraction over direct and indirect exit points. Direct exits correspond to
// tailcalls and Return, while indirect exits store the result in a variable
// and then jump to an exit label.
class ExitPoint {
private:
using CodeAssemblerLabel = compiler::CodeAssemblerLabel;
public:
using IndirectReturnHandler = std::function<void(TNode<Object> result)>;
explicit ExitPoint(CodeStubAssembler* assembler)
: ExitPoint(assembler, nullptr) {}
ExitPoint(CodeStubAssembler* assembler,
const IndirectReturnHandler& indirect_return_handler)
: asm_(assembler), indirect_return_handler_(indirect_return_handler) {}
ExitPoint(CodeStubAssembler* assembler, CodeAssemblerLabel* out,
compiler::CodeAssembler::TVariable<Object>* var_result)
: ExitPoint(assembler, [=](TNode<Object> result) {
*var_result = result;
assembler->Goto(out);
}) {
DCHECK_EQ(out != nullptr, var_result != nullptr);
}
template <class... TArgs>
void ReturnCallRuntime(Runtime::FunctionId function, TNode<Context> context,
TArgs... args) {
if (IsDirect()) {
asm_->TailCallRuntime(function, context, args...);
} else {
indirect_return_handler_(asm_->CallRuntime(function, context, args...));
}
}
template <class... TArgs>
void ReturnCallStub(Callable const& callable, TNode<Context> context,
TArgs... args) {
if (IsDirect()) {
asm_->TailCallStub(callable, context, args...);
} else {
indirect_return_handler_(asm_->CallStub(callable, context, args...));
}
}
template <class... TArgs>
void ReturnCallStub(const CallInterfaceDescriptor& descriptor,
TNode<Code> target, TNode<Context> context,
TArgs... args) {
if (IsDirect()) {
asm_->TailCallStub(descriptor, target, context, args...);
} else {
indirect_return_handler_(
asm_->CallStub(descriptor, target, context, args...));
}
}
void Return(const TNode<Object> result) {
if (IsDirect()) {
asm_->Return(result);
} else {
indirect_return_handler_(result);
}
}
bool IsDirect() const { return !indirect_return_handler_; }
private:
CodeStubAssembler* const asm_;
IndirectReturnHandler indirect_return_handler_;
};
} // namespace internal
} // namespace v8
#endif // V8_IC_ACCESSOR_ASSEMBLER_H_