diff options
Diffstat (limited to 'chromium/v8/src/baseline/baseline-compiler.cc')
| -rw-r--r-- | chromium/v8/src/baseline/baseline-compiler.cc | 889 |
1 files changed, 462 insertions, 427 deletions
diff --git a/chromium/v8/src/baseline/baseline-compiler.cc b/chromium/v8/src/baseline/baseline-compiler.cc index 3d599c11fd5..9c6e3f10e6d 100644 --- a/chromium/v8/src/baseline/baseline-compiler.cc +++ b/chromium/v8/src/baseline/baseline-compiler.cc @@ -4,8 +4,9 @@ // TODO(v8:11421): Remove #if once baseline compiler is ported to other // architectures. +#include "src/base/bits.h" #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_ARM64 || \ - V8_TARGET_ARCH_ARM + V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_RISCV64 #include "src/baseline/baseline-compiler.h" @@ -19,7 +20,7 @@ #include "src/builtins/builtins.h" #include "src/codegen/assembler.h" #include "src/codegen/compiler.h" -#include "src/codegen/interface-descriptors.h" +#include "src/codegen/interface-descriptors-inl.h" #include "src/codegen/machine-type.h" #include "src/codegen/macro-assembler-inl.h" #include "src/common/globals.h" @@ -40,6 +41,8 @@ #include "src/baseline/ia32/baseline-compiler-ia32-inl.h" #elif V8_TARGET_ARCH_ARM #include "src/baseline/arm/baseline-compiler-arm-inl.h" +#elif V8_TARGET_ARCH_RISCV64 +#include "src/baseline/riscv64/baseline-compiler-riscv64-inl.h" #else #error Unsupported target architecture. #endif @@ -48,9 +51,9 @@ namespace v8 { namespace internal { namespace baseline { -template <typename LocalIsolate> +template <typename IsolateT> Handle<ByteArray> BytecodeOffsetTableBuilder::ToBytecodeOffsetTable( - LocalIsolate* isolate) { + IsolateT* isolate) { if (bytes_.empty()) return isolate->factory()->empty_byte_array(); Handle<ByteArray> table = isolate->factory()->NewByteArray( static_cast<int>(bytes_.size()), AllocationType::kOld); @@ -68,6 +71,7 @@ bool Clobbers(Register target, TaggedIndex index) { return false; } bool Clobbers(Register target, int32_t imm) { return false; } bool Clobbers(Register target, RootIndex index) { return false; } bool Clobbers(Register target, interpreter::Register reg) { return false; } +bool Clobbers(Register target, interpreter::RegisterList list) { return false; } // We don't know what's inside machine registers or operands, so assume they // match. @@ -97,134 +101,151 @@ bool MachineTypeMatches(MachineType type, interpreter::Register reg) { return type.IsTagged(); } -template <typename... Args> +template <typename Descriptor, typename... Args> struct CheckArgsHelper; -template <> -struct CheckArgsHelper<> { - static void Check(BaselineAssembler* masm, CallInterfaceDescriptor descriptor, - int i) { - if (descriptor.AllowVarArgs()) { - CHECK_GE(i, descriptor.GetParameterCount()); +template <typename Descriptor> +struct CheckArgsHelper<Descriptor> { + static void Check(BaselineAssembler* masm, int i) { + if (Descriptor::AllowVarArgs()) { + CHECK_GE(i, Descriptor::GetParameterCount()); } else { - CHECK_EQ(i, descriptor.GetParameterCount()); + CHECK_EQ(i, Descriptor::GetParameterCount()); } } }; -template <typename Arg, typename... Args> -struct CheckArgsHelper<Arg, Args...> { - static void Check(BaselineAssembler* masm, CallInterfaceDescriptor descriptor, - int i, Arg arg, Args... args) { - if (i >= descriptor.GetParameterCount()) { - CHECK(descriptor.AllowVarArgs()); +template <typename Descriptor, typename Arg, typename... Args> +struct CheckArgsHelper<Descriptor, Arg, Args...> { + static void Check(BaselineAssembler* masm, int i, Arg arg, Args... args) { + if (i >= Descriptor::GetParameterCount()) { + CHECK(Descriptor::AllowVarArgs()); return; } - CHECK(MachineTypeMatches(descriptor.GetParameterType(i), arg)); - CheckArgsHelper<Args...>::Check(masm, descriptor, i + 1, args...); + CHECK(MachineTypeMatches(Descriptor().GetParameterType(i), arg)); + CheckArgsHelper<Descriptor, Args...>::Check(masm, i + 1, args...); } }; -template <typename... Args> -struct CheckArgsHelper<interpreter::RegisterList, Args...> { - static void Check(BaselineAssembler* masm, CallInterfaceDescriptor descriptor, - int i, interpreter::RegisterList list, Args... args) { +template <typename Descriptor, typename... Args> +struct CheckArgsHelper<Descriptor, interpreter::RegisterList, Args...> { + static void Check(BaselineAssembler* masm, int i, + interpreter::RegisterList list, Args... args) { for (int reg_index = 0; reg_index < list.register_count(); ++reg_index, ++i) { - if (i >= descriptor.GetParameterCount()) { - CHECK(descriptor.AllowVarArgs()); + if (i >= Descriptor::GetParameterCount()) { + CHECK(Descriptor::AllowVarArgs()); return; } - CHECK( - MachineTypeMatches(descriptor.GetParameterType(i), list[reg_index])); + CHECK(MachineTypeMatches(Descriptor().GetParameterType(i), + list[reg_index])); } - CheckArgsHelper<Args...>::Check(masm, descriptor, i, args...); + CheckArgsHelper<Descriptor, Args...>::Check(masm, i, args...); } }; -template <typename... Args> -void CheckArgs(BaselineAssembler* masm, CallInterfaceDescriptor descriptor, - Args... args) { - CheckArgsHelper<Args...>::Check(masm, descriptor, 0, args...); +template <typename Descriptor, typename... Args> +void CheckArgs(BaselineAssembler* masm, Args... args) { + CheckArgsHelper<Descriptor, Args...>::Check(masm, 0, args...); +} + +void CheckSettingDoesntClobber(Register target) {} +template <typename Arg, typename... Args> +void CheckSettingDoesntClobber(Register target, Arg arg, Args... args) { + DCHECK(!Clobbers(target, arg)); + CheckSettingDoesntClobber(target, args...); } #else // DEBUG -template <typename... Args> +template <typename Descriptor, typename... Args> void CheckArgs(Args... args) {} +template <typename... Args> +void CheckSettingDoesntClobber(Register target, Args... args) {} + #endif // DEBUG -template <typename... Args> +template <typename Descriptor, int ArgIndex, bool kIsRegister, typename... Args> struct ArgumentSettingHelper; -template <> -struct ArgumentSettingHelper<> { - static void Set(BaselineAssembler* masm, CallInterfaceDescriptor descriptor, - int i) {} - static void CheckSettingDoesntClobber(Register target, int arg_index) {} +template <typename Descriptor, int ArgIndex, bool kIsRegister> +struct ArgumentSettingHelper<Descriptor, ArgIndex, kIsRegister> { + static void Set(BaselineAssembler* masm) { + // Should only ever be called for the end of register arguments. + STATIC_ASSERT(ArgIndex == Descriptor::GetRegisterParameterCount()); + } }; -template <typename Arg, typename... Args> -struct ArgumentSettingHelper<Arg, Args...> { - static void Set(BaselineAssembler* masm, CallInterfaceDescriptor descriptor, - int i, Arg arg, Args... args) { - if (i < descriptor.GetRegisterParameterCount()) { - Register target = descriptor.GetRegisterParameter(i); - ArgumentSettingHelper<Args...>::CheckSettingDoesntClobber(target, i + 1, - args...); - masm->Move(target, arg); - ArgumentSettingHelper<Args...>::Set(masm, descriptor, i + 1, args...); - } else if (descriptor.GetStackArgumentOrder() == - StackArgumentOrder::kDefault) { - masm->Push(arg, args...); - } else { - masm->PushReverse(arg, args...); - } +template <typename Descriptor, int ArgIndex, typename Arg, typename... Args> +struct ArgumentSettingHelper<Descriptor, ArgIndex, true, Arg, Args...> { + static void Set(BaselineAssembler* masm, Arg arg, Args... args) { + STATIC_ASSERT(ArgIndex < Descriptor::GetRegisterParameterCount()); + Register target = Descriptor::GetRegisterParameter(ArgIndex); + CheckSettingDoesntClobber(target, args...); + masm->Move(target, arg); + ArgumentSettingHelper<Descriptor, ArgIndex + 1, + (ArgIndex + 1 < + Descriptor::GetRegisterParameterCount()), + Args...>::Set(masm, args...); } - static void CheckSettingDoesntClobber(Register target, int arg_index, Arg arg, - Args... args) { - DCHECK(!Clobbers(target, arg)); - ArgumentSettingHelper<Args...>::CheckSettingDoesntClobber( - target, arg_index + 1, args...); +}; + +template <typename Descriptor, int ArgIndex> +struct ArgumentSettingHelper<Descriptor, ArgIndex, true, + interpreter::RegisterList> { + static void Set(BaselineAssembler* masm, interpreter::RegisterList list) { + STATIC_ASSERT(ArgIndex < Descriptor::GetRegisterParameterCount()); + DCHECK_EQ(ArgIndex + list.register_count(), + Descriptor::GetRegisterParameterCount()); + for (int i = 0; ArgIndex + i < Descriptor::GetRegisterParameterCount(); + ++i) { + Register target = Descriptor::GetRegisterParameter(ArgIndex + i); + masm->Move(target, masm->RegisterFrameOperand(list[i])); + } } }; -// Specialization for interpreter::RegisterList which iterates it. -// RegisterLists are only allowed to be the last argument. -template <> -struct ArgumentSettingHelper<interpreter::RegisterList> { - static void Set(BaselineAssembler* masm, CallInterfaceDescriptor descriptor, - int i, interpreter::RegisterList list) { - // Either all the values are in machine registers, or they're all on the - // stack. - if (i < descriptor.GetRegisterParameterCount()) { - for (int reg_index = 0; reg_index < list.register_count(); - ++reg_index, ++i) { - Register target = descriptor.GetRegisterParameter(i); - masm->Move(target, masm->RegisterFrameOperand(list[reg_index])); - } - } else if (descriptor.GetStackArgumentOrder() == - StackArgumentOrder::kDefault) { - masm->Push(list); +template <typename Descriptor, int ArgIndex, typename Arg, typename... Args> +struct ArgumentSettingHelper<Descriptor, ArgIndex, false, Arg, Args...> { + static void Set(BaselineAssembler* masm, Arg arg, Args... args) { + if (Descriptor::kStackArgumentOrder == StackArgumentOrder::kDefault) { + masm->Push(arg, args...); } else { - masm->PushReverse(list); + masm->PushReverse(arg, args...); } } - static void CheckSettingDoesntClobber(Register target, int arg_index, - interpreter::RegisterList arg) {} }; -template <typename... Args> -void MoveArgumentsForDescriptor(BaselineAssembler* masm, - CallInterfaceDescriptor descriptor, - Args... args) { - CheckArgs(masm, descriptor, args...); - ArgumentSettingHelper<Args...>::Set(masm, descriptor, 0, args...); +template <Builtins::Name kBuiltin, typename... Args> +void MoveArgumentsForBuiltin(BaselineAssembler* masm, Args... args) { + using Descriptor = typename CallInterfaceDescriptorFor<kBuiltin>::type; + CheckArgs<Descriptor>(masm, args...); + ArgumentSettingHelper<Descriptor, 0, + (0 < Descriptor::GetRegisterParameterCount()), + Args...>::Set(masm, args...); + if (Descriptor::HasContextParameter()) { + masm->LoadContext(Descriptor::ContextRegister()); + } } } // namespace detail +namespace { +// Rough upper-bound estimate. Copying the data is most likely more expensive +// than pre-allocating a large enough buffer. +#ifdef V8_TARGET_ARCH_IA32 +const int kAverageBytecodeToInstructionRatio = 5; +#else +const int kAverageBytecodeToInstructionRatio = 7; +#endif +std::unique_ptr<AssemblerBuffer> AllocateBuffer( + Handle<BytecodeArray> bytecodes) { + int estimated_size = bytecodes->length() * kAverageBytecodeToInstructionRatio; + return NewAssemblerBuffer(RoundUp(estimated_size, 4 * KB)); +} +} // namespace + BaselineCompiler::BaselineCompiler( Isolate* isolate, Handle<SharedFunctionInfo> shared_function_info, Handle<BytecodeArray> bytecode) @@ -232,20 +253,26 @@ BaselineCompiler::BaselineCompiler( stats_(isolate->counters()->runtime_call_stats()), shared_function_info_(shared_function_info), bytecode_(bytecode), - masm_(isolate, CodeObjectRequired::kNo), + masm_(isolate, CodeObjectRequired::kNo, AllocateBuffer(bytecode)), basm_(&masm_), iterator_(bytecode_), zone_(isolate->allocator(), ZONE_NAME), labels_(zone_.NewArray<BaselineLabels*>(bytecode_->length())) { MemsetPointer(labels_, nullptr, bytecode_->length()); + + // Empirically determined expected size of the offset table at the 95th %ile, + // based on the size of the bytecode, to be: + // + // 16 + (bytecode size) / 4 + bytecode_offset_table_builder_.Reserve( + base::bits::RoundUpToPowerOfTwo(16 + bytecode_->Size() / 4)); } #define __ basm_. void BaselineCompiler::GenerateCode() { { - RuntimeCallTimerScope runtimeTimer( - stats_, RuntimeCallCounterId::kCompileBaselinePreVisit); + RCS_SCOPE(stats_, RuntimeCallCounterId::kCompileBaselinePreVisit); for (; !iterator_.done(); iterator_.Advance()) { PreVisitSingleBytecode(); } @@ -257,8 +284,7 @@ void BaselineCompiler::GenerateCode() { __ CodeEntry(); { - RuntimeCallTimerScope runtimeTimer( - stats_, RuntimeCallCounterId::kCompileBaselineVisit); + RCS_SCOPE(stats_, RuntimeCallCounterId::kCompileBaselineVisit); Prologue(); AddPosition(); for (; !iterator_.done(); iterator_.Advance()) { @@ -453,7 +479,7 @@ void BaselineCompiler::VisitSingleBytecode() { } void BaselineCompiler::VerifyFrame() { - if (__ emit_debug_code()) { + if (FLAG_debug_code) { __ RecordComment("[ Verify frame"); __ RecordComment(" -- Verify frame size"); VerifyFrameSize(); @@ -552,28 +578,18 @@ Label* BaselineCompiler::BuildForwardJumpLabel() { return &threaded_label->label; } -template <typename... Args> -void BaselineCompiler::CallBuiltin(Builtins::Name builtin, Args... args) { +template <Builtins::Name kBuiltin, typename... Args> +void BaselineCompiler::CallBuiltin(Args... args) { __ RecordComment("[ CallBuiltin"); - CallInterfaceDescriptor descriptor = - Builtins::CallInterfaceDescriptorFor(builtin); - detail::MoveArgumentsForDescriptor(&basm_, descriptor, args...); - if (descriptor.HasContextParameter()) { - __ LoadContext(descriptor.ContextRegister()); - } - __ CallBuiltin(builtin); + detail::MoveArgumentsForBuiltin<kBuiltin>(&basm_, args...); + __ CallBuiltin(kBuiltin); __ RecordComment("]"); } -template <typename... Args> -void BaselineCompiler::TailCallBuiltin(Builtins::Name builtin, Args... args) { - CallInterfaceDescriptor descriptor = - Builtins::CallInterfaceDescriptorFor(builtin); - detail::MoveArgumentsForDescriptor(&basm_, descriptor, args...); - if (descriptor.HasContextParameter()) { - __ LoadContext(descriptor.ContextRegister()); - } - __ TailCallBuiltin(builtin); +template <Builtins::Name kBuiltin, typename... Args> +void BaselineCompiler::TailCallBuiltin(Args... args) { + detail::MoveArgumentsForBuiltin<kBuiltin>(&basm_, args...); + __ TailCallBuiltin(kBuiltin); } template <typename... Args> @@ -584,27 +600,17 @@ void BaselineCompiler::CallRuntime(Runtime::FunctionId function, Args... args) { } // Returns into kInterpreterAccumulatorRegister -void BaselineCompiler::JumpIfToBoolean(bool do_jump_if_true, Register reg, - Label* label, Label::Distance distance) { - Label end; - Label::Distance end_distance = Label::kNear; - - Label* true_label = do_jump_if_true ? label : &end; - Label::Distance true_distance = do_jump_if_true ? distance : end_distance; - Label* false_label = do_jump_if_true ? &end : label; - Label::Distance false_distance = do_jump_if_true ? end_distance : distance; - - BaselineAssembler::ScratchRegisterScope scratch_scope(&basm_); - Register to_boolean = scratch_scope.AcquireScratch(); - { - SaveAccumulatorScope accumulator_scope(&basm_); - CallBuiltin(Builtins::kToBoolean, reg); - __ Move(to_boolean, kInterpreterAccumulatorRegister); - } - __ JumpIfRoot(to_boolean, RootIndex::kTrueValue, true_label, true_distance); - if (false_label != &end) __ Jump(false_label, false_distance); - - __ Bind(&end); +void BaselineCompiler::JumpIfToBoolean(bool do_jump_if_true, Label* label, + Label::Distance distance) { + CallBuiltin<Builtins::kToBooleanForBaselineJump>( + kInterpreterAccumulatorRegister); + // ToBooleanForBaselineJump returns the ToBoolean value into return reg 1, and + // the original value into kInterpreterAccumulatorRegister, so we don't have + // to worry about it getting clobbered. + STATIC_ASSERT(kReturnRegister0 == kInterpreterAccumulatorRegister); + __ Cmp(kReturnRegister1, Smi::FromInt(0)); + __ JumpIf(do_jump_if_true ? Condition::kNotEqual : Condition::kEqual, label, + distance); } void BaselineCompiler::VisitLdaZero() { @@ -641,22 +647,21 @@ void BaselineCompiler::VisitLdaConstant() { } void BaselineCompiler::VisitLdaGlobal() { - CallBuiltin(Builtins::kLoadGlobalICBaseline, - Constant<Name>(0), // name - IndexAsTagged(1)); // slot + CallBuiltin<Builtins::kLoadGlobalICBaseline>(Constant<Name>(0), // name + IndexAsTagged(1)); // slot } void BaselineCompiler::VisitLdaGlobalInsideTypeof() { - CallBuiltin(Builtins::kLoadGlobalICInsideTypeofBaseline, - Constant<Name>(0), // name - IndexAsTagged(1)); // slot + CallBuiltin<Builtins::kLoadGlobalICInsideTypeofBaseline>( + Constant<Name>(0), // name + IndexAsTagged(1)); // slot } void BaselineCompiler::VisitStaGlobal() { - CallBuiltin(Builtins::kStoreGlobalICBaseline, - Constant<Name>(0), // name - kInterpreterAccumulatorRegister, // value - IndexAsTagged(1)); // slot + CallBuiltin<Builtins::kStoreGlobalICBaseline>( + Constant<Name>(0), // name + kInterpreterAccumulatorRegister, // value + IndexAsTagged(1)); // slot } void BaselineCompiler::VisitPushContext() { @@ -730,13 +735,13 @@ void BaselineCompiler::VisitLdaLookupSlot() { } void BaselineCompiler::VisitLdaLookupContextSlot() { - CallBuiltin(Builtins::kLookupContextBaseline, Constant<Name>(0), - UintAsTagged(2), IndexAsTagged(1)); + CallBuiltin<Builtins::kLookupContextBaseline>( + Constant<Name>(0), UintAsTagged(2), IndexAsTagged(1)); } void BaselineCompiler::VisitLdaLookupGlobalSlot() { - CallBuiltin(Builtins::kLookupGlobalICBaseline, Constant<Name>(0), - UintAsTagged(2), IndexAsTagged(1)); + CallBuiltin<Builtins::kLookupGlobalICBaseline>( + Constant<Name>(0), UintAsTagged(2), IndexAsTagged(1)); } void BaselineCompiler::VisitLdaLookupSlotInsideTypeof() { @@ -744,13 +749,13 @@ void BaselineCompiler::VisitLdaLookupSlotInsideTypeof() { } void BaselineCompiler::VisitLdaLookupContextSlotInsideTypeof() { - CallBuiltin(Builtins::kLookupContextInsideTypeofBaseline, Constant<Name>(0), - UintAsTagged(2), IndexAsTagged(1)); + CallBuiltin<Builtins::kLookupContextInsideTypeofBaseline>( + Constant<Name>(0), UintAsTagged(2), IndexAsTagged(1)); } void BaselineCompiler::VisitLdaLookupGlobalSlotInsideTypeof() { - CallBuiltin(Builtins::kLookupGlobalICInsideTypeofBaseline, Constant<Name>(0), - UintAsTagged(2), IndexAsTagged(1)); + CallBuiltin<Builtins::kLookupGlobalICInsideTypeofBaseline>( + Constant<Name>(0), UintAsTagged(2), IndexAsTagged(1)); } void BaselineCompiler::VisitStaLookupSlot() { @@ -793,14 +798,13 @@ void BaselineCompiler::VisitMov() { } void BaselineCompiler::VisitLdaNamedProperty() { - CallBuiltin(Builtins::kLoadICBaseline, - RegisterOperand(0), // object - Constant<Name>(1), // name - IndexAsTagged(2)); // slot + CallBuiltin<Builtins::kLoadICBaseline>(RegisterOperand(0), // object + Constant<Name>(1), // name + IndexAsTagged(2)); // slot } void BaselineCompiler::VisitLdaNamedPropertyNoFeedback() { - CallBuiltin(Builtins::kGetProperty, RegisterOperand(0), Constant<Name>(1)); + CallBuiltin<Builtins::kGetProperty>(RegisterOperand(0), Constant<Name>(1)); } void BaselineCompiler::VisitLdaNamedPropertyFromSuper() { @@ -808,19 +812,19 @@ void BaselineCompiler::VisitLdaNamedPropertyFromSuper() { LoadWithReceiverAndVectorDescriptor::LookupStartObjectRegister(), kInterpreterAccumulatorRegister); - CallBuiltin(Builtins::kLoadSuperICBaseline, - RegisterOperand(0), // object - LoadWithReceiverAndVectorDescriptor:: - LookupStartObjectRegister(), // lookup start - Constant<Name>(1), // name - IndexAsTagged(2)); // slot + CallBuiltin<Builtins::kLoadSuperICBaseline>( + RegisterOperand(0), // object + LoadWithReceiverAndVectorDescriptor:: + LookupStartObjectRegister(), // lookup start + Constant<Name>(1), // name + IndexAsTagged(2)); // slot } void BaselineCompiler::VisitLdaKeyedProperty() { - CallBuiltin(Builtins::kKeyedLoadICBaseline, - RegisterOperand(0), // object - kInterpreterAccumulatorRegister, // key - IndexAsTagged(1)); // slot + CallBuiltin<Builtins::kKeyedLoadICBaseline>( + RegisterOperand(0), // object + kInterpreterAccumulatorRegister, // key + IndexAsTagged(1)); // slot } void BaselineCompiler::VisitLdaModuleVariable() { @@ -878,11 +882,11 @@ void BaselineCompiler::VisitStaModuleVariable() { } void BaselineCompiler::VisitStaNamedProperty() { - CallBuiltin(Builtins::kStoreICBaseline, - RegisterOperand(0), // object - Constant<Name>(1), // name - kInterpreterAccumulatorRegister, // value - IndexAsTagged(2)); // slot + CallBuiltin<Builtins::kStoreICBaseline>( + RegisterOperand(0), // object + Constant<Name>(1), // name + kInterpreterAccumulatorRegister, // value + IndexAsTagged(2)); // slot } void BaselineCompiler::VisitStaNamedPropertyNoFeedback() { @@ -900,19 +904,19 @@ void BaselineCompiler::VisitStaNamedOwnProperty() { } void BaselineCompiler::VisitStaKeyedProperty() { - CallBuiltin(Builtins::kKeyedStoreICBaseline, - RegisterOperand(0), // object - RegisterOperand(1), // key - kInterpreterAccumulatorRegister, // value - IndexAsTagged(2)); // slot + CallBuiltin<Builtins::kKeyedStoreICBaseline>( + RegisterOperand(0), // object + RegisterOperand(1), // key + kInterpreterAccumulatorRegister, // value + IndexAsTagged(2)); // slot } void BaselineCompiler::VisitStaInArrayLiteral() { - CallBuiltin(Builtins::kStoreInArrayLiteralICBaseline, - RegisterOperand(0), // object - RegisterOperand(1), // name - kInterpreterAccumulatorRegister, // value - IndexAsTagged(2)); // slot + CallBuiltin<Builtins::kStoreInArrayLiteralICBaseline>( + RegisterOperand(0), // object + RegisterOperand(1), // name + kInterpreterAccumulatorRegister, // value + IndexAsTagged(2)); // slot } void BaselineCompiler::VisitStaDataPropertyInLiteral() { @@ -934,140 +938,149 @@ void BaselineCompiler::VisitCollectTypeProfile() { } void BaselineCompiler::VisitAdd() { - CallBuiltin(Builtins::kAdd_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kAdd_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitSub() { - CallBuiltin(Builtins::kSubtract_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kSubtract_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitMul() { - CallBuiltin(Builtins::kMultiply_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kMultiply_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitDiv() { - CallBuiltin(Builtins::kDivide_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kDivide_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitMod() { - CallBuiltin(Builtins::kModulus_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kModulus_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitExp() { - CallBuiltin(Builtins::kExponentiate_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kExponentiate_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitBitwiseOr() { - CallBuiltin(Builtins::kBitwiseOr_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kBitwiseOr_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitBitwiseXor() { - CallBuiltin(Builtins::kBitwiseXor_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kBitwiseXor_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitBitwiseAnd() { - CallBuiltin(Builtins::kBitwiseAnd_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kBitwiseAnd_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitShiftLeft() { - CallBuiltin(Builtins::kShiftLeft_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kShiftLeft_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitShiftRight() { - CallBuiltin(Builtins::kShiftRight_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); + CallBuiltin<Builtins::kShiftRight_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitShiftRightLogical() { - CallBuiltin(Builtins::kShiftRightLogical_Baseline, RegisterOperand(0), - kInterpreterAccumulatorRegister, Index(1)); -} - -void BaselineCompiler::BuildBinopWithConstant(Builtins::Name builtin_name) { - CallBuiltin(builtin_name, kInterpreterAccumulatorRegister, IntAsSmi(0), - Index(1)); + CallBuiltin<Builtins::kShiftRightLogical_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitAddSmi() { - BuildBinopWithConstant(Builtins::kAdd_Baseline); + CallBuiltin<Builtins::kAdd_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitSubSmi() { - BuildBinopWithConstant(Builtins::kSubtract_Baseline); + CallBuiltin<Builtins::kSubtract_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitMulSmi() { - BuildBinopWithConstant(Builtins::kMultiply_Baseline); + CallBuiltin<Builtins::kMultiply_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitDivSmi() { - BuildBinopWithConstant(Builtins::kDivide_Baseline); + CallBuiltin<Builtins::kDivide_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitModSmi() { - BuildBinopWithConstant(Builtins::kModulus_Baseline); + CallBuiltin<Builtins::kModulus_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitExpSmi() { - BuildBinopWithConstant(Builtins::kExponentiate_Baseline); + CallBuiltin<Builtins::kExponentiate_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitBitwiseOrSmi() { - BuildBinopWithConstant(Builtins::kBitwiseOr_Baseline); + CallBuiltin<Builtins::kBitwiseOr_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitBitwiseXorSmi() { - BuildBinopWithConstant(Builtins::kBitwiseXor_Baseline); + CallBuiltin<Builtins::kBitwiseXor_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitBitwiseAndSmi() { - BuildBinopWithConstant(Builtins::kBitwiseAnd_Baseline); + CallBuiltin<Builtins::kBitwiseAnd_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitShiftLeftSmi() { - BuildBinopWithConstant(Builtins::kShiftLeft_Baseline); + CallBuiltin<Builtins::kShiftLeft_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitShiftRightSmi() { - BuildBinopWithConstant(Builtins::kShiftRight_Baseline); + CallBuiltin<Builtins::kShiftRight_Baseline>(kInterpreterAccumulatorRegister, + IntAsSmi(0), Index(1)); } void BaselineCompiler::VisitShiftRightLogicalSmi() { - BuildBinopWithConstant(Builtins::kShiftRightLogical_Baseline); + CallBuiltin<Builtins::kShiftRightLogical_Baseline>( + kInterpreterAccumulatorRegister, IntAsSmi(0), Index(1)); } -void BaselineCompiler::BuildUnop(Builtins::Name builtin_name) { - CallBuiltin(builtin_name, - kInterpreterAccumulatorRegister, // value - Index(0)); // slot +void BaselineCompiler::VisitInc() { + CallBuiltin<Builtins::kIncrement_Baseline>(kInterpreterAccumulatorRegister, + Index(0)); } -void BaselineCompiler::VisitInc() { BuildUnop(Builtins::kIncrement_Baseline); } - -void BaselineCompiler::VisitDec() { BuildUnop(Builtins::kDecrement_Baseline); } +void BaselineCompiler::VisitDec() { + CallBuiltin<Builtins::kDecrement_Baseline>(kInterpreterAccumulatorRegister, + Index(0)); +} -void BaselineCompiler::VisitNegate() { BuildUnop(Builtins::kNegate_Baseline); } +void BaselineCompiler::VisitNegate() { + CallBuiltin<Builtins::kNegate_Baseline>(kInterpreterAccumulatorRegister, + Index(0)); +} void BaselineCompiler::VisitBitwiseNot() { - BuildUnop(Builtins::kBitwiseNot_Baseline); + CallBuiltin<Builtins::kBitwiseNot_Baseline>(kInterpreterAccumulatorRegister, + Index(0)); } void BaselineCompiler::VisitToBooleanLogicalNot() { SelectBooleanConstant(kInterpreterAccumulatorRegister, [&](Label* if_true, Label::Distance distance) { - JumpIfToBoolean(false, - kInterpreterAccumulatorRegister, - if_true, distance); + JumpIfToBoolean(false, if_true, distance); }); } @@ -1081,23 +1094,23 @@ void BaselineCompiler::VisitLogicalNot() { } void BaselineCompiler::VisitTypeOf() { - CallBuiltin(Builtins::kTypeof, kInterpreterAccumulatorRegister); + CallBuiltin<Builtins::kTypeof>(kInterpreterAccumulatorRegister); } void BaselineCompiler::VisitDeletePropertyStrict() { BaselineAssembler::ScratchRegisterScope scratch_scope(&basm_); Register scratch = scratch_scope.AcquireScratch(); __ Move(scratch, kInterpreterAccumulatorRegister); - CallBuiltin(Builtins::kDeleteProperty, RegisterOperand(0), scratch, - Smi::FromEnum(LanguageMode::kStrict)); + CallBuiltin<Builtins::kDeleteProperty>(RegisterOperand(0), scratch, + Smi::FromEnum(LanguageMode::kStrict)); } void BaselineCompiler::VisitDeletePropertySloppy() { BaselineAssembler::ScratchRegisterScope scratch_scope(&basm_); Register scratch = scratch_scope.AcquireScratch(); __ Move(scratch, kInterpreterAccumulatorRegister); - CallBuiltin(Builtins::kDeleteProperty, RegisterOperand(0), scratch, - Smi::FromEnum(LanguageMode::kSloppy)); + CallBuiltin<Builtins::kDeleteProperty>(RegisterOperand(0), scratch, + Smi::FromEnum(LanguageMode::kSloppy)); } void BaselineCompiler::VisitGetSuperConstructor() { @@ -1106,87 +1119,115 @@ void BaselineCompiler::VisitGetSuperConstructor() { __ LoadPrototype(prototype, kInterpreterAccumulatorRegister); StoreRegister(0, prototype); } -template <typename... Args> -void BaselineCompiler::BuildCall(ConvertReceiverMode mode, uint32_t slot, - uint32_t arg_count, Args... args) { - Builtins::Name builtin; + +namespace { +constexpr Builtins::Name ConvertReceiverModeToCompactBuiltin( + ConvertReceiverMode mode) { switch (mode) { case ConvertReceiverMode::kAny: - builtin = Builtins::kCall_ReceiverIsAny_Baseline; + return Builtins::kCall_ReceiverIsAny_Baseline_Compact; break; case ConvertReceiverMode::kNullOrUndefined: - builtin = Builtins::kCall_ReceiverIsNullOrUndefined_Baseline; + return Builtins::kCall_ReceiverIsNullOrUndefined_Baseline_Compact; break; case ConvertReceiverMode::kNotNullOrUndefined: - builtin = Builtins::kCall_ReceiverIsNotNullOrUndefined_Baseline; + return Builtins::kCall_ReceiverIsNotNullOrUndefined_Baseline_Compact; break; - default: - UNREACHABLE(); } - CallBuiltin(builtin, - RegisterOperand(0), // kFunction - arg_count, // kActualArgumentsCount - slot, // kSlot - args...); // Arguments +} +constexpr Builtins::Name ConvertReceiverModeToBuiltin( + ConvertReceiverMode mode) { + switch (mode) { + case ConvertReceiverMode::kAny: + return Builtins::kCall_ReceiverIsAny_Baseline; + break; + case ConvertReceiverMode::kNullOrUndefined: + return Builtins::kCall_ReceiverIsNullOrUndefined_Baseline; + break; + case ConvertReceiverMode::kNotNullOrUndefined: + return Builtins::kCall_ReceiverIsNotNullOrUndefined_Baseline; + break; + } +} +} // namespace + +template <ConvertReceiverMode kMode, typename... Args> +void BaselineCompiler::BuildCall(uint32_t slot, uint32_t arg_count, + Args... args) { + uint32_t bitfield; + if (CallTrampoline_Baseline_CompactDescriptor::EncodeBitField(arg_count, slot, + &bitfield)) { + CallBuiltin<ConvertReceiverModeToCompactBuiltin(kMode)>( + RegisterOperand(0), // kFunction + bitfield, // kActualArgumentsCount | kSlot + args...); // Arguments + } else { + CallBuiltin<ConvertReceiverModeToBuiltin(kMode)>( + RegisterOperand(0), // kFunction + arg_count, // kActualArgumentsCount + slot, // kSlot + args...); // Arguments + } } void BaselineCompiler::VisitCallAnyReceiver() { interpreter::RegisterList args = iterator().GetRegisterListOperand(1); uint32_t arg_count = args.register_count() - 1; // Remove receiver. - BuildCall(ConvertReceiverMode::kAny, Index(3), arg_count, args); + BuildCall<ConvertReceiverMode::kAny>(Index(3), arg_count, args); } void BaselineCompiler::VisitCallProperty() { interpreter::RegisterList args = iterator().GetRegisterListOperand(1); uint32_t arg_count = args.register_count() - 1; // Remove receiver. - BuildCall(ConvertReceiverMode::kNotNullOrUndefined, Index(3), arg_count, - args); + BuildCall<ConvertReceiverMode::kNotNullOrUndefined>(Index(3), arg_count, + args); } void BaselineCompiler::VisitCallProperty0() { - BuildCall(ConvertReceiverMode::kNotNullOrUndefined, Index(2), 0, - RegisterOperand(1)); + BuildCall<ConvertReceiverMode::kNotNullOrUndefined>(Index(2), 0, + RegisterOperand(1)); } void BaselineCompiler::VisitCallProperty1() { - BuildCall(ConvertReceiverMode::kNotNullOrUndefined, Index(3), 1, - RegisterOperand(1), RegisterOperand(2)); + BuildCall<ConvertReceiverMode::kNotNullOrUndefined>( + Index(3), 1, RegisterOperand(1), RegisterOperand(2)); } void BaselineCompiler::VisitCallProperty2() { - BuildCall(ConvertReceiverMode::kNotNullOrUndefined, Index(4), 2, - RegisterOperand(1), RegisterOperand(2), RegisterOperand(3)); + BuildCall<ConvertReceiverMode::kNotNullOrUndefined>( + Index(4), 2, RegisterOperand(1), RegisterOperand(2), RegisterOperand(3)); } void BaselineCompiler::VisitCallUndefinedReceiver() { interpreter::RegisterList args = iterator().GetRegisterListOperand(1); uint32_t arg_count = args.register_count(); - BuildCall(ConvertReceiverMode::kNullOrUndefined, Index(3), arg_count, - RootIndex::kUndefinedValue, args); + BuildCall<ConvertReceiverMode::kNullOrUndefined>( + Index(3), arg_count, RootIndex::kUndefinedValue, args); } void BaselineCompiler::VisitCallUndefinedReceiver0() { - BuildCall(ConvertReceiverMode::kNullOrUndefined, Index(1), 0, - RootIndex::kUndefinedValue); + BuildCall<ConvertReceiverMode::kNullOrUndefined>(Index(1), 0, + RootIndex::kUndefinedValue); } void BaselineCompiler::VisitCallUndefinedReceiver1() { - BuildCall(ConvertReceiverMode::kNullOrUndefined, Index(2), 1, - RootIndex::kUndefinedValue, RegisterOperand(1)); + BuildCall<ConvertReceiverMode::kNullOrUndefined>( + Index(2), 1, RootIndex::kUndefinedValue, RegisterOperand(1)); } void BaselineCompiler::VisitCallUndefinedReceiver2() { - BuildCall(ConvertReceiverMode::kNullOrUndefined, Index(3), 2, - RootIndex::kUndefinedValue, RegisterOperand(1), RegisterOperand(2)); + BuildCall<ConvertReceiverMode::kNullOrUndefined>( + Index(3), 2, RootIndex::kUndefinedValue, RegisterOperand(1), + RegisterOperand(2)); } void BaselineCompiler::VisitCallNoFeedback() { interpreter::RegisterList args = iterator().GetRegisterListOperand(1); uint32_t arg_count = args.register_count(); - CallBuiltin(Builtins::kCall_ReceiverIsAny, - RegisterOperand(0), // kFunction - arg_count - 1, // kActualArgumentsCount - args); + CallBuiltin<Builtins::kCall_ReceiverIsAny>( + RegisterOperand(0), // kFunction + arg_count - 1, // kActualArgumentsCount + args); } void BaselineCompiler::VisitCallWithSpread() { @@ -1198,12 +1239,12 @@ void BaselineCompiler::VisitCallWithSpread() { uint32_t arg_count = args.register_count() - 1; // Remove receiver. - CallBuiltin(Builtins::kCallWithSpread_Baseline, - RegisterOperand(0), // kFunction - arg_count, // kActualArgumentsCount - spread_register, // kSpread - Index(3), // kSlot - args); + CallBuiltin<Builtins::kCallWithSpread_Baseline>( + RegisterOperand(0), // kFunction + arg_count, // kActualArgumentsCount + spread_register, // kSpread + Index(3), // kSlot + args); } void BaselineCompiler::VisitCallRuntime() { @@ -1226,11 +1267,11 @@ void BaselineCompiler::VisitCallJSRuntime() { __ LoadContext(kContextRegister); __ LoadNativeContextSlot(kJavaScriptCallTargetRegister, iterator().GetNativeContextIndexOperand(0)); - CallBuiltin(Builtins::kCall_ReceiverIsNullOrUndefined, - kJavaScriptCallTargetRegister, // kFunction - arg_count, // kActualArgumentsCount - RootIndex::kUndefinedValue, // kReceiver - args); + CallBuiltin<Builtins::kCall_ReceiverIsNullOrUndefined>( + kJavaScriptCallTargetRegister, // kFunction + arg_count, // kActualArgumentsCount + RootIndex::kUndefinedValue, // kReceiver + args); } void BaselineCompiler::VisitInvokeIntrinsic() { @@ -1301,29 +1342,25 @@ void BaselineCompiler::VisitIntrinsicIsSmi(interpreter::RegisterList args) { void BaselineCompiler::VisitIntrinsicCopyDataProperties( interpreter::RegisterList args) { - CallBuiltin(Builtins::kCopyDataProperties, args); + CallBuiltin<Builtins::kCopyDataProperties>(args); } void BaselineCompiler::VisitIntrinsicCreateIterResultObject( interpreter::RegisterList args) { - CallBuiltin(Builtins::kCreateIterResultObject, args); + CallBuiltin<Builtins::kCreateIterResultObject>(args); } void BaselineCompiler::VisitIntrinsicHasProperty( interpreter::RegisterList args) { - CallBuiltin(Builtins::kHasProperty, args); -} - -void BaselineCompiler::VisitIntrinsicToString(interpreter::RegisterList args) { - CallBuiltin(Builtins::kToString, args); + CallBuiltin<Builtins::kHasProperty>(args); } void BaselineCompiler::VisitIntrinsicToLength(interpreter::RegisterList args) { - CallBuiltin(Builtins::kToLength, args); + CallBuiltin<Builtins::kToLength>(args); } void BaselineCompiler::VisitIntrinsicToObject(interpreter::RegisterList args) { - CallBuiltin(Builtins::kToObject, args); + CallBuiltin<Builtins::kToObject>(args); } void BaselineCompiler::VisitIntrinsicCall(interpreter::RegisterList args) { @@ -1335,20 +1372,20 @@ void BaselineCompiler::VisitIntrinsicCall(interpreter::RegisterList args) { args = args.PopLeft(); uint32_t arg_count = args.register_count(); - CallBuiltin(Builtins::kCall_ReceiverIsAny, - kJavaScriptCallTargetRegister, // kFunction - arg_count - 1, // kActualArgumentsCount - args); + CallBuiltin<Builtins::kCall_ReceiverIsAny>( + kJavaScriptCallTargetRegister, // kFunction + arg_count - 1, // kActualArgumentsCount + args); } void BaselineCompiler::VisitIntrinsicCreateAsyncFromSyncIterator( interpreter::RegisterList args) { - CallBuiltin(Builtins::kCreateAsyncFromSyncIteratorBaseline, args[0]); + CallBuiltin<Builtins::kCreateAsyncFromSyncIteratorBaseline>(args[0]); } void BaselineCompiler::VisitIntrinsicCreateJSGeneratorObject( interpreter::RegisterList args) { - CallBuiltin(Builtins::kCreateGeneratorObject, args); + CallBuiltin<Builtins::kCreateGeneratorObject>(args); } void BaselineCompiler::VisitIntrinsicGeneratorGetResumeMode( @@ -1370,69 +1407,69 @@ void BaselineCompiler::VisitIntrinsicGeneratorClose( void BaselineCompiler::VisitIntrinsicGetImportMetaObject( interpreter::RegisterList args) { - CallBuiltin(Builtins::kGetImportMetaObjectBaseline); + CallBuiltin<Builtins::kGetImportMetaObjectBaseline>(); } void BaselineCompiler::VisitIntrinsicAsyncFunctionAwaitCaught( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncFunctionAwaitCaught, args); + CallBuiltin<Builtins::kAsyncFunctionAwaitCaught>(args); } void BaselineCompiler::VisitIntrinsicAsyncFunctionAwaitUncaught( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncFunctionAwaitUncaught, args); + CallBuiltin<Builtins::kAsyncFunctionAwaitUncaught>(args); } void BaselineCompiler::VisitIntrinsicAsyncFunctionEnter( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncFunctionEnter, args); + CallBuiltin<Builtins::kAsyncFunctionEnter>(args); } void BaselineCompiler::VisitIntrinsicAsyncFunctionReject( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncFunctionReject, args); + CallBuiltin<Builtins::kAsyncFunctionReject>(args); } void BaselineCompiler::VisitIntrinsicAsyncFunctionResolve( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncFunctionResolve, args); + CallBuiltin<Builtins::kAsyncFunctionResolve>(args); } void BaselineCompiler::VisitIntrinsicAsyncGeneratorAwaitCaught( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncGeneratorAwaitCaught, args); + CallBuiltin<Builtins::kAsyncGeneratorAwaitCaught>(args); } void BaselineCompiler::VisitIntrinsicAsyncGeneratorAwaitUncaught( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncGeneratorAwaitUncaught, args); + CallBuiltin<Builtins::kAsyncGeneratorAwaitUncaught>(args); } void BaselineCompiler::VisitIntrinsicAsyncGeneratorReject( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncGeneratorReject, args); + CallBuiltin<Builtins::kAsyncGeneratorReject>(args); } void BaselineCompiler::VisitIntrinsicAsyncGeneratorResolve( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncGeneratorResolve, args); + CallBuiltin<Builtins::kAsyncGeneratorResolve>(args); } void BaselineCompiler::VisitIntrinsicAsyncGeneratorYield( interpreter::RegisterList args) { - CallBuiltin(Builtins::kAsyncGeneratorYield, args); + CallBuiltin<Builtins::kAsyncGeneratorYield>(args); } void BaselineCompiler::VisitConstruct() { interpreter::RegisterList args = iterator().GetRegisterListOperand(1); uint32_t arg_count = args.register_count(); - CallBuiltin(Builtins::kConstruct_Baseline, - RegisterOperand(0), // kFunction - kInterpreterAccumulatorRegister, // kNewTarget - arg_count, // kActualArgumentsCount - Index(3), // kSlot - RootIndex::kUndefinedValue, // kReceiver - args); + CallBuiltin<Builtins::kConstruct_Baseline>( + RegisterOperand(0), // kFunction + kInterpreterAccumulatorRegister, // kNewTarget + arg_count, // kActualArgumentsCount + Index(3), // kSlot + RootIndex::kUndefinedValue, // kReceiver + args); } void BaselineCompiler::VisitConstructWithSpread() { @@ -1444,51 +1481,50 @@ void BaselineCompiler::VisitConstructWithSpread() { uint32_t arg_count = args.register_count(); + using Descriptor = + CallInterfaceDescriptorFor<Builtins::kConstructWithSpread_Baseline>::type; Register new_target = - Builtins::CallInterfaceDescriptorFor( - Builtins::kConstructWithSpread_Baseline) - .GetRegisterParameter( - ConstructWithSpread_BaselineDescriptor::kNewTarget); + Descriptor::GetRegisterParameter(Descriptor::kNewTarget); __ Move(new_target, kInterpreterAccumulatorRegister); - CallBuiltin(Builtins::kConstructWithSpread_Baseline, - RegisterOperand(0), // kFunction - new_target, // kNewTarget - arg_count, // kActualArgumentsCount - Index(3), // kSlot - spread_register, // kSpread - RootIndex::kUndefinedValue, // kReceiver - args); -} - -void BaselineCompiler::BuildCompare(Builtins::Name builtin_name) { - CallBuiltin(builtin_name, RegisterOperand(0), // lhs - kInterpreterAccumulatorRegister, // rhs - Index(1)); // slot + CallBuiltin<Builtins::kConstructWithSpread_Baseline>( + RegisterOperand(0), // kFunction + new_target, // kNewTarget + arg_count, // kActualArgumentsCount + Index(3), // kSlot + spread_register, // kSpread + RootIndex::kUndefinedValue, // kReceiver + args); } void BaselineCompiler::VisitTestEqual() { - BuildCompare(Builtins::kEqual_Baseline); + CallBuiltin<Builtins::kEqual_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitTestEqualStrict() { - BuildCompare(Builtins::kStrictEqual_Baseline); + CallBuiltin<Builtins::kStrictEqual_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitTestLessThan() { - BuildCompare(Builtins::kLessThan_Baseline); + CallBuiltin<Builtins::kLessThan_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitTestGreaterThan() { - BuildCompare(Builtins::kGreaterThan_Baseline); + CallBuiltin<Builtins::kGreaterThan_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitTestLessThanOrEqual() { - BuildCompare(Builtins::kLessThanOrEqual_Baseline); + CallBuiltin<Builtins::kLessThanOrEqual_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitTestGreaterThanOrEqual() { - BuildCompare(Builtins::kGreaterThanOrEqual_Baseline); + CallBuiltin<Builtins::kGreaterThanOrEqual_Baseline>( + RegisterOperand(0), kInterpreterAccumulatorRegister, Index(1)); } void BaselineCompiler::VisitTestReferenceEqual() { @@ -1502,21 +1538,21 @@ void BaselineCompiler::VisitTestReferenceEqual() { } void BaselineCompiler::VisitTestInstanceOf() { - Register callable = - Builtins::CallInterfaceDescriptorFor(Builtins::kInstanceOf_Baseline) - .GetRegisterParameter(Compare_BaselineDescriptor::kRight); + using Descriptor = + CallInterfaceDescriptorFor<Builtins::kInstanceOf_Baseline>::type; + Register callable = Descriptor::GetRegisterParameter(Descriptor::kRight); __ Move(callable, kInterpreterAccumulatorRegister); - CallBuiltin(Builtins::kInstanceOf_Baseline, - RegisterOperand(0), // object - callable, // callable - Index(1)); // slot + + CallBuiltin<Builtins::kInstanceOf_Baseline>(RegisterOperand(0), // object + callable, // callable + Index(1)); // slot } void BaselineCompiler::VisitTestIn() { - CallBuiltin(Builtins::kKeyedHasICBaseline, - kInterpreterAccumulatorRegister, // object - RegisterOperand(0), // name - IndexAsTagged(1)); // slot + CallBuiltin<Builtins::kKeyedHasICBaseline>( + kInterpreterAccumulatorRegister, // object + RegisterOperand(0), // name + IndexAsTagged(1)); // slot } void BaselineCompiler::VisitTestUndetectable() { @@ -1727,36 +1763,36 @@ void BaselineCompiler::VisitTestTypeOf() { void BaselineCompiler::VisitToName() { SaveAccumulatorScope save_accumulator(&basm_); - CallBuiltin(Builtins::kToName, kInterpreterAccumulatorRegister); + CallBuiltin<Builtins::kToName>(kInterpreterAccumulatorRegister); StoreRegister(0, kInterpreterAccumulatorRegister); } void BaselineCompiler::VisitToNumber() { - CallBuiltin(Builtins::kToNumber_Baseline, kInterpreterAccumulatorRegister, - Index(0)); + CallBuiltin<Builtins::kToNumber_Baseline>(kInterpreterAccumulatorRegister, + Index(0)); } void BaselineCompiler::VisitToNumeric() { - CallBuiltin(Builtins::kToNumeric_Baseline, kInterpreterAccumulatorRegister, - Index(0)); + CallBuiltin<Builtins::kToNumeric_Baseline>(kInterpreterAccumulatorRegister, + Index(0)); } void BaselineCompiler::VisitToObject() { SaveAccumulatorScope save_accumulator(&basm_); - CallBuiltin(Builtins::kToObject, kInterpreterAccumulatorRegister); + CallBuiltin<Builtins::kToObject>(kInterpreterAccumulatorRegister); StoreRegister(0, kInterpreterAccumulatorRegister); } void BaselineCompiler::VisitToString() { - CallBuiltin(Builtins::kToString, kInterpreterAccumulatorRegister); + CallBuiltin<Builtins::kToString>(kInterpreterAccumulatorRegister); } void BaselineCompiler::VisitCreateRegExpLiteral() { - CallBuiltin(Builtins::kCreateRegExpLiteral, - FeedbackVector(), // feedback vector - IndexAsTagged(1), // slot - Constant<HeapObject>(0), // pattern - FlagAsSmi(2)); // flags + CallBuiltin<Builtins::kCreateRegExpLiteral>( + FeedbackVector(), // feedback vector + IndexAsTagged(1), // slot + Constant<HeapObject>(0), // pattern + FlagAsSmi(2)); // flags } void BaselineCompiler::VisitCreateArrayLiteral() { @@ -1765,11 +1801,11 @@ void BaselineCompiler::VisitCreateArrayLiteral() { interpreter::CreateArrayLiteralFlags::FlagsBits::decode(flags)); if (flags & interpreter::CreateArrayLiteralFlags::FastCloneSupportedBit::kMask) { - CallBuiltin(Builtins::kCreateShallowArrayLiteral, - FeedbackVector(), // feedback vector - IndexAsTagged(1), // slot - Constant<HeapObject>(0), // constant elements - Smi::FromInt(flags_raw)); // flags + CallBuiltin<Builtins::kCreateShallowArrayLiteral>( + FeedbackVector(), // feedback vector + IndexAsTagged(1), // slot + Constant<HeapObject>(0), // constant elements + Smi::FromInt(flags_raw)); // flags } else { CallRuntime(Runtime::kCreateArrayLiteral, FeedbackVector(), // feedback vector @@ -1780,13 +1816,13 @@ void BaselineCompiler::VisitCreateArrayLiteral() { } void BaselineCompiler::VisitCreateArrayFromIterable() { - CallBuiltin(Builtins::kIterableToListWithSymbolLookup, - kInterpreterAccumulatorRegister); // iterable + CallBuiltin<Builtins::kIterableToListWithSymbolLookup>( + kInterpreterAccumulatorRegister); // iterable } void BaselineCompiler::VisitCreateEmptyArrayLiteral() { - CallBuiltin(Builtins::kCreateEmptyArrayLiteral, FeedbackVector(), - IndexAsTagged(0)); + CallBuiltin<Builtins::kCreateEmptyArrayLiteral>(FeedbackVector(), + IndexAsTagged(0)); } void BaselineCompiler::VisitCreateObjectLiteral() { @@ -1795,11 +1831,11 @@ void BaselineCompiler::VisitCreateObjectLiteral() { interpreter::CreateObjectLiteralFlags::FlagsBits::decode(flags)); if (flags & interpreter::CreateObjectLiteralFlags::FastCloneSupportedBit::kMask) { - CallBuiltin(Builtins::kCreateShallowObjectLiteral, - FeedbackVector(), // feedback vector - IndexAsTagged(1), // slot - Constant<ObjectBoilerplateDescription>(0), // boilerplate - Smi::FromInt(flags_raw)); // flags + CallBuiltin<Builtins::kCreateShallowObjectLiteral>( + FeedbackVector(), // feedback vector + IndexAsTagged(1), // slot + Constant<ObjectBoilerplateDescription>(0), // boilerplate + Smi::FromInt(flags_raw)); // flags } else { CallRuntime(Runtime::kCreateObjectLiteral, FeedbackVector(), // feedback vector @@ -1810,39 +1846,39 @@ void BaselineCompiler::VisitCreateObjectLiteral() { } void BaselineCompiler::VisitCreateEmptyObjectLiteral() { - CallBuiltin(Builtins::kCreateEmptyLiteralObject); + CallBuiltin<Builtins::kCreateEmptyLiteralObject>(); } void BaselineCompiler::VisitCloneObject() { uint32_t flags = Flag(1); int32_t raw_flags = interpreter::CreateObjectLiteralFlags::FlagsBits::decode(flags); - CallBuiltin(Builtins::kCloneObjectICBaseline, - RegisterOperand(0), // source - Smi::FromInt(raw_flags), // flags - IndexAsTagged(2)); // slot + CallBuiltin<Builtins::kCloneObjectICBaseline>( + RegisterOperand(0), // source + Smi::FromInt(raw_flags), // flags + IndexAsTagged(2)); // slot } void BaselineCompiler::VisitGetTemplateObject() { BaselineAssembler::ScratchRegisterScope scratch_scope(&basm_); - CallBuiltin(Builtins::kGetTemplateObject, - shared_function_info_, // shared function info - Constant<HeapObject>(0), // description - Index(1), // slot - FeedbackVector()); // feedback_vector + CallBuiltin<Builtins::kGetTemplateObject>( + shared_function_info_, // shared function info + Constant<HeapObject>(0), // description + Index(1), // slot + FeedbackVector()); // feedback_vector } void BaselineCompiler::VisitCreateClosure() { Register feedback_cell = - Builtins::CallInterfaceDescriptorFor(Builtins::kFastNewClosure) - .GetRegisterParameter(FastNewClosureDescriptor::kFeedbackCell); + FastNewClosureBaselineDescriptor::GetRegisterParameter( + FastNewClosureBaselineDescriptor::kFeedbackCell); LoadClosureFeedbackArray(feedback_cell); __ LoadFixedArrayElement(feedback_cell, feedback_cell, Index(1)); uint32_t flags = Flag(2); if (interpreter::CreateClosureFlags::FastNewClosureBit::decode(flags)) { - CallBuiltin(Builtins::kFastNewClosure, Constant<SharedFunctionInfo>(0), - feedback_cell); + CallBuiltin<Builtins::kFastNewClosureBaseline>( + Constant<SharedFunctionInfo>(0), feedback_cell); } else { Runtime::FunctionId function_id = interpreter::CreateClosureFlags::PretenuredBit::decode(flags) @@ -1868,7 +1904,7 @@ void BaselineCompiler::VisitCreateFunctionContext() { if (slot_count < static_cast<uint32_t>( ConstructorBuiltins::MaximumFunctionContextSlots())) { DCHECK_EQ(info->scope_type(), ScopeType::FUNCTION_SCOPE); - CallBuiltin(Builtins::kFastNewFunctionContextFunction, info, slot_count); + CallBuiltin<Builtins::kFastNewFunctionContextFunction>(info, slot_count); } else { CallRuntime(Runtime::kNewFunctionContext, Constant<ScopeInfo>(0)); } @@ -1880,7 +1916,7 @@ void BaselineCompiler::VisitCreateEvalContext() { if (slot_count < static_cast<uint32_t>( ConstructorBuiltins::MaximumFunctionContextSlots())) { DCHECK_EQ(info->scope_type(), ScopeType::EVAL_SCOPE); - CallBuiltin(Builtins::kFastNewFunctionContextEval, info, slot_count); + CallBuiltin<Builtins::kFastNewFunctionContextEval>(info, slot_count); } else { CallRuntime(Runtime::kNewFunctionContext, Constant<ScopeInfo>(0)); } @@ -1896,16 +1932,16 @@ void BaselineCompiler::VisitCreateMappedArguments() { if (shared_function_info_->has_duplicate_parameters()) { CallRuntime(Runtime::kNewSloppyArguments, __ FunctionOperand()); } else { - CallBuiltin(Builtins::kFastNewSloppyArguments, __ FunctionOperand()); + CallBuiltin<Builtins::kFastNewSloppyArguments>(__ FunctionOperand()); } } void BaselineCompiler::VisitCreateUnmappedArguments() { - CallBuiltin(Builtins::kFastNewStrictArguments, __ FunctionOperand()); + CallBuiltin<Builtins::kFastNewStrictArguments>(__ FunctionOperand()); } void BaselineCompiler::VisitCreateRestParameter() { - CallBuiltin(Builtins::kFastNewRestArguments, __ FunctionOperand()); + CallBuiltin<Builtins::kFastNewRestArguments>(__ FunctionOperand()); } void BaselineCompiler::VisitJumpLoop() { @@ -1919,7 +1955,7 @@ void BaselineCompiler::VisitJumpLoop() { int loop_depth = iterator().GetImmediateOperand(1); __ CompareByte(osr_level, loop_depth); __ JumpIf(Condition::kUnsignedLessThanEqual, &osr_not_armed); - CallBuiltin(Builtins::kBaselineOnStackReplacement); + CallBuiltin<Builtins::kBaselineOnStackReplacement>(); __ RecordComment("]"); __ Bind(&osr_not_armed); @@ -1972,16 +2008,14 @@ void BaselineCompiler::VisitJumpIfToBooleanFalseConstant() { void BaselineCompiler::VisitJumpIfToBooleanTrue() { Label dont_jump; - JumpIfToBoolean(false, kInterpreterAccumulatorRegister, &dont_jump, - Label::kNear); + JumpIfToBoolean(false, &dont_jump, Label::kNear); UpdateInterruptBudgetAndDoInterpreterJump(); __ Bind(&dont_jump); } void BaselineCompiler::VisitJumpIfToBooleanFalse() { Label dont_jump; - JumpIfToBoolean(true, kInterpreterAccumulatorRegister, &dont_jump, - Label::kNear); + JumpIfToBoolean(true, &dont_jump, Label::kNear); UpdateInterruptBudgetAndDoInterpreterJump(); __ Bind(&dont_jump); } @@ -2057,13 +2091,13 @@ void BaselineCompiler::VisitSwitchOnSmiNoFeedback() { } void BaselineCompiler::VisitForInEnumerate() { - CallBuiltin(Builtins::kForInEnumerate, RegisterOperand(0)); + CallBuiltin<Builtins::kForInEnumerate>(RegisterOperand(0)); } void BaselineCompiler::VisitForInPrepare() { StoreRegister(0, kInterpreterAccumulatorRegister); - CallBuiltin(Builtins::kForInPrepare, kInterpreterAccumulatorRegister, - IndexAsTagged(1), FeedbackVector()); + CallBuiltin<Builtins::kForInPrepare>(kInterpreterAccumulatorRegister, + IndexAsTagged(1), FeedbackVector()); interpreter::Register first = iterator().GetRegisterOperand(0); interpreter::Register second(first.index() + 1); interpreter::Register third(first.index() + 2); @@ -2085,13 +2119,12 @@ void BaselineCompiler::VisitForInContinue() { void BaselineCompiler::VisitForInNext() { interpreter::Register cache_type, cache_array; std::tie(cache_type, cache_array) = iterator().GetRegisterPairOperand(2); - CallBuiltin(Builtins::kForInNext, - Index(3), // vector slot - RegisterOperand(0), // object - cache_array, // cache array - cache_type, // cache type - RegisterOperand(1), // index - FeedbackVector()); // feedback vector + CallBuiltin<Builtins::kForInNext>(Index(3), // vector slot + RegisterOperand(0), // object + cache_array, // cache array + cache_type, // cache type + RegisterOperand(1), // index + FeedbackVector()); // feedback vector } void BaselineCompiler::VisitForInStep() { @@ -2131,8 +2164,8 @@ void BaselineCompiler::VisitReturn() { int parameter_count_without_receiver = parameter_count - 1; // Exclude the receiver to simplify the // computation. We'll account for it at the end. - TailCallBuiltin(Builtins::kBaselineLeaveFrame, - parameter_count_without_receiver, -profiling_weight); + TailCallBuiltin<Builtins::kBaselineLeaveFrame>( + parameter_count_without_receiver, -profiling_weight); __ RecordComment("]"); } @@ -2235,10 +2268,11 @@ void BaselineCompiler::VisitSuspendGenerator() { int bytecode_offset = BytecodeArray::kHeaderSize + iterator().current_offset(); - CallBuiltin(Builtins::kSuspendGeneratorBaseline, generator_object, - static_cast<int>(Uint(3)), // suspend_id - bytecode_offset, - static_cast<int>(RegisterCount(2))); // register_count + CallBuiltin<Builtins::kSuspendGeneratorBaseline>( + generator_object, + static_cast<int>(Uint(3)), // suspend_id + bytecode_offset, + static_cast<int>(RegisterCount(2))); // register_count } VisitReturn(); } @@ -2248,26 +2282,27 @@ void BaselineCompiler::VisitResumeGenerator() { BaselineAssembler::ScratchRegisterScope scratch_scope(&basm_); Register generator_object = scratch_scope.AcquireScratch(); LoadRegister(generator_object, 0); - CallBuiltin(Builtins::kResumeGeneratorBaseline, generator_object, - static_cast<int>(RegisterCount(2))); // register_count + CallBuiltin<Builtins::kResumeGeneratorBaseline>( + generator_object, + static_cast<int>(RegisterCount(2))); // register_count } void BaselineCompiler::VisitGetIterator() { - CallBuiltin(Builtins::kGetIteratorBaseline, - RegisterOperand(0), // receiver - IndexAsTagged(1), // load_slot - IndexAsTagged(2)); // call_slot + CallBuiltin<Builtins::kGetIteratorBaseline>(RegisterOperand(0), // receiver + IndexAsTagged(1), // load_slot + IndexAsTagged(2)); // call_slot } void BaselineCompiler::VisitDebugger() { SaveAccumulatorScope accumulator_scope(&basm_); - CallBuiltin(Builtins::kHandleDebuggerStatement); + CallRuntime(Runtime::kHandleDebuggerStatement); } void BaselineCompiler::VisitIncBlockCounter() { SaveAccumulatorScope accumulator_scope(&basm_); - CallBuiltin(Builtins::kIncBlockCounter, __ FunctionOperand(), - IndexAsSmi(0)); // coverage array slot + CallBuiltin<Builtins::kIncBlockCounter>( + __ FunctionOperand(), + IndexAsSmi(0)); // coverage array slot } void BaselineCompiler::VisitAbort() { |