maglev-assembler-x64-inl.h | Explore in Territory

// Copyright 2022 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_MAGLEV_X64_MAGLEV_ASSEMBLER_X64_INL_H_
#define V8_MAGLEV_X64_MAGLEV_ASSEMBLER_X64_INL_H_

#include <tuple>
#include <type_traits>
#include <utility>

#include "src/codegen/interface-descriptors-inl.h"
#include "src/codegen/macro-assembler-inl.h"
#include "src/codegen/x64/assembler-x64.h"
#include "src/common/globals.h"
#include "src/compiler/compilation-dependencies.h"
#include "src/maglev/maglev-assembler.h"
#include "src/maglev/maglev-basic-block.h"
#include "src/maglev/maglev-code-gen-state.h"

namespace v8 {
namespace internal {
namespace maglev {

constexpr Condition ConditionForFloat64(Operation operation) { … }

constexpr Condition ConditionForNaN() { … }

inline ScaleFactor ScaleFactorFromInt(int n) { … }

class MaglevAssembler::TemporaryRegisterScope
    : public TemporaryRegisterScopeBase<TemporaryRegisterScope> { … };

inline MapCompare::MapCompare(MaglevAssembler* masm, Register object,
                              size_t map_count)
    : … { … }

void MapCompare::Generate(Handle<Map> map, Condition cond, Label* if_true,
                          Label::Distance distance) { … }

Register MapCompare::GetMap() { … }

int MapCompare::TemporaryCount(size_t map_count) { … }

namespace detail {

template <typename... Args>
struct PushAllHelper;

template <>
struct PushAllHelper<> { … };

inline void PushInput(MaglevAssembler* masm, const Input& input) { … }

template <typename T, typename... Args>
inline void PushIterator(MaglevAssembler* masm, base::iterator_range<T> range,
                         Args... args) { … }

template <typename T, typename... Args>
inline void PushIteratorReverse(MaglevAssembler* masm,
                                base::iterator_range<T> range, Args... args) { … }

PushAllHelper<Input, Args...>;
PushAllHelper<Arg, Args...>;

}  // namespace detail

template <typename... T>
void MaglevAssembler::Push(T... vals) { … }

template <typename... T>
void MaglevAssembler::PushReverse(T... vals) { … }

inline void MaglevAssembler::BindJumpTarget(Label* label) { … }

inline void MaglevAssembler::BindBlock(BasicBlock* block) { … }

inline void MaglevAssembler::SmiTagInt32AndSetFlags(Register dst,
                                                    Register src) { … }

inline void MaglevAssembler::CheckInt32IsSmi(Register obj, Label* fail,
                                             Register scratch) { … }

inline void MaglevAssembler::SmiAddConstant(Register dst, Register src,
                                            int value, Label* fail,
                                            Label::Distance distance) { … }

inline void MaglevAssembler::SmiSubConstant(Register dst, Register src,
                                            int value, Label* fail,
                                            Label::Distance distance) { … }

inline void MaglevAssembler::MoveHeapNumber(Register dst, double value) { … }

inline Condition MaglevAssembler::IsRootConstant(Input input,
                                                 RootIndex root_index) { … }

inline Register MaglevAssembler::GetFramePointer() { … }

inline MemOperand MaglevAssembler::GetStackSlot(
    const compiler::AllocatedOperand& operand) { … }

inline MemOperand MaglevAssembler::ToMemOperand(
    const compiler::InstructionOperand& operand) { … }

inline MemOperand MaglevAssembler::ToMemOperand(const ValueLocation& location) { … }

inline void MaglevAssembler::BuildTypedArrayDataPointer(Register data_pointer,
                                                        Register object) { … }

inline MemOperand MaglevAssembler::TypedArrayElementOperand(
    Register data_pointer, Register index, int element_size) { … }

inline MemOperand MaglevAssembler::DataViewElementOperand(Register data_pointer,
                                                          Register index) { … }

inline void MaglevAssembler::LoadTaggedFieldByIndex(Register result,
                                                    Register object,
                                                    Register index, int scale,
                                                    int offset) { … }

inline void MaglevAssembler::LoadBoundedSizeFromObject(Register result,
                                                       Register object,
                                                       int offset) { … }

inline void MaglevAssembler::LoadExternalPointerField(Register result,
                                                      Operand operand) { … }

void MaglevAssembler::LoadFixedArrayElement(Register result, Register array,
                                            Register index) { … }

void MaglevAssembler::LoadFixedArrayElementWithoutDecompressing(
    Register result, Register array, Register index) { … }

void MaglevAssembler::LoadFixedDoubleArrayElement(DoubleRegister result,
                                                  Register array,
                                                  Register index) { … }

inline void MaglevAssembler::StoreFixedDoubleArrayElement(
    Register array, Register index, DoubleRegister value) { … }

inline void MaglevAssembler::LoadSignedField(Register result, Operand operand,
                                             int size) { … }

inline void MaglevAssembler::LoadUnsignedField(Register result, Operand operand,
                                               int size) { … }

inline void MaglevAssembler::SetSlotAddressForTaggedField(Register slot_reg,
                                                          Register object,
                                                          int offset) { … }
inline void MaglevAssembler::SetSlotAddressForFixedArrayElement(
    Register slot_reg, Register object, Register index) { … }

inline void MaglevAssembler::StoreTaggedFieldNoWriteBarrier(Register object,
                                                            int offset,
                                                            Register value) { … }

inline void MaglevAssembler::StoreFixedArrayElementNoWriteBarrier(
    Register array, Register index, Register value) { … }

inline void MaglevAssembler::StoreTaggedSignedField(Register object, int offset,
                                                    Register value) { … }

inline void MaglevAssembler::StoreTaggedSignedField(Register object, int offset,
                                                    Tagged<Smi> value) { … }

inline void MaglevAssembler::StoreInt32Field(Register object, int offset,
                                             int32_t value) { … }

inline void MaglevAssembler::StoreField(Operand operand, Register value,
                                        int size) { … }

#ifdef V8_ENABLE_SANDBOX

inline void MaglevAssembler::StoreTrustedPointerFieldNoWriteBarrier(
    Register object, int offset, Register value) { … }

#endif  // V8_ENABLE_SANDBOX

inline void MaglevAssembler::ReverseByteOrder(Register value, int size) { … }

inline MemOperand MaglevAssembler::StackSlotOperand(StackSlot stack_slot) { … }

inline void MaglevAssembler::IncrementInt32(Register reg) { … }

inline void MaglevAssembler::DecrementInt32(Register reg) { … }

inline void MaglevAssembler::AddInt32(Register reg, int amount) { … }

inline void MaglevAssembler::AndInt32(Register reg, int mask) { … }

inline void MaglevAssembler::OrInt32(Register reg, int mask) { … }

inline void MaglevAssembler::ShiftLeft(Register reg, int amount) { … }

inline void MaglevAssembler::IncrementAddress(Register reg, int32_t delta) { … }

inline void MaglevAssembler::LoadAddress(Register dst, MemOperand location) { … }

inline void MaglevAssembler::Call(Label* target) { … }

inline void MaglevAssembler::EmitEnterExitFrame(int extra_slots,
                                                StackFrame::Type frame_type,
                                                Register c_function,
                                                Register scratch) { … }

inline void MaglevAssembler::Move(StackSlot dst, Register src) { … }

inline void MaglevAssembler::Move(StackSlot dst, DoubleRegister src) { … }

inline void MaglevAssembler::Move(Register dst, StackSlot src) { … }

inline void MaglevAssembler::Move(DoubleRegister dst, StackSlot src) { … }

inline void MaglevAssembler::Move(MemOperand dst, Register src) { … }

inline void MaglevAssembler::Move(Register dst, Tagged<TaggedIndex> i) { … }

inline void MaglevAssembler::Move(DoubleRegister dst, DoubleRegister src) { … }

inline void MaglevAssembler::Move(Register dst, Tagged<Smi> src) { … }

inline void MaglevAssembler::Move(Register dst, ExternalReference src) { … }

inline void MaglevAssembler::Move(Register dst, MemOperand src) { … }

inline void MaglevAssembler::Move(Register dst, Register src) { … }

inline void MaglevAssembler::Move(Register dst, int32_t i) { … }

inline void MaglevAssembler::Move(Register dst, uint32_t i) { … }

inline void MaglevAssembler::Move(Register dst, IndirectPointerTag i) { … }

inline void MaglevAssembler::Move(DoubleRegister dst, double n) { … }

inline void MaglevAssembler::Move(DoubleRegister dst, Float64 n) { … }

inline void MaglevAssembler::Move(Register dst, Handle<HeapObject> obj) { … }

void MaglevAssembler::MoveTagged(Register dst, Handle<HeapObject> obj) { … }

inline void MaglevAssembler::LoadFloat32(DoubleRegister dst, MemOperand src) { … }
inline void MaglevAssembler::StoreFloat32(MemOperand dst, DoubleRegister src) { … }
inline void MaglevAssembler::LoadFloat64(DoubleRegister dst, MemOperand src) { … }
inline void MaglevAssembler::StoreFloat64(MemOperand dst, DoubleRegister src) { … }

inline void MaglevAssembler::LoadUnalignedFloat64(DoubleRegister dst,
                                                  Register base,
                                                  Register index) { … }
inline void MaglevAssembler::LoadUnalignedFloat64AndReverseByteOrder(
    DoubleRegister dst, Register base, Register index) { … }
inline void MaglevAssembler::StoreUnalignedFloat64(Register base,
                                                   Register index,
                                                   DoubleRegister src) { … }
inline void MaglevAssembler::ReverseByteOrderAndStoreUnalignedFloat64(
    Register base, Register index, DoubleRegister src) { … }

inline void MaglevAssembler::SignExtend32To64Bits(Register dst, Register src) { … }
inline void MaglevAssembler::NegateInt32(Register val) { … }

inline void MaglevAssembler::ToUint8Clamped(Register result,
                                            DoubleRegister value, Label* min,
                                            Label* max, Label* done) { … }

template <typename NodeT>
inline void MaglevAssembler::DeoptIfBufferDetached(Register array,
                                                   Register scratch,
                                                   NodeT* node) { … }

inline void MaglevAssembler::LoadByte(Register dst, MemOperand src) { … }

inline Condition MaglevAssembler::IsCallableAndNotUndetectable(
    Register map, Register scratch) { … }

inline Condition MaglevAssembler::IsNotCallableNorUndetactable(
    Register map, Register scratch) { … }

inline void MaglevAssembler::LoadInstanceType(Register instance_type,
                                              Register heap_object) { … }

inline void MaglevAssembler::JumpIfObjectType(Register heap_object,
                                              InstanceType type, Label* target,
                                              Label::Distance distance) { … }

inline void MaglevAssembler::JumpIfNotObjectType(Register heap_object,
                                                 InstanceType type,
                                                 Label* target,
                                                 Label::Distance distance) { … }

inline void MaglevAssembler::AssertObjectType(Register heap_object,
                                              InstanceType type,
                                              AbortReason reason) { … }

inline void MaglevAssembler::BranchOnObjectType(
    Register heap_object, InstanceType type, Label* if_true,
    Label::Distance true_distance, bool fallthrough_when_true, Label* if_false,
    Label::Distance false_distance, bool fallthrough_when_false) { … }

inline void MaglevAssembler::JumpIfObjectTypeInRange(Register heap_object,
                                                     InstanceType lower_limit,
                                                     InstanceType higher_limit,
                                                     Label* target,
                                                     Label::Distance distance) { … }

inline void MaglevAssembler::JumpIfObjectTypeNotInRange(
    Register heap_object, InstanceType lower_limit, InstanceType higher_limit,
    Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::AssertObjectTypeInRange(Register heap_object,
                                                     InstanceType lower_limit,
                                                     InstanceType higher_limit,
                                                     AbortReason reason) { … }

inline void MaglevAssembler::BranchOnObjectTypeInRange(
    Register heap_object, InstanceType lower_limit, InstanceType higher_limit,
    Label* if_true, Label::Distance true_distance, bool fallthrough_when_true,
    Label* if_false, Label::Distance false_distance,
    bool fallthrough_when_false) { … }

inline void MaglevAssembler::JumpIfJSAnyIsNotPrimitive(
    Register heap_object, Label* target, Label::Distance distance) { … }

#if V8_STATIC_ROOTS_BOOL
inline void MaglevAssembler::JumpIfObjectInRange(Register heap_object,
                                                 Tagged_t lower_limit,
                                                 Tagged_t higher_limit,
                                                 Label* target,
                                                 Label::Distance distance) { … }

inline void MaglevAssembler::JumpIfObjectNotInRange(Register heap_object,
                                                    Tagged_t lower_limit,
                                                    Tagged_t higher_limit,
                                                    Label* target,
                                                    Label::Distance distance) { … }

inline void MaglevAssembler::AssertObjectInRange(Register heap_object,
                                                 Tagged_t lower_limit,
                                                 Tagged_t higher_limit,
                                                 AbortReason reason) { … }
#endif

inline void MaglevAssembler::CompareMapWithRoot(Register object,
                                                RootIndex index,
                                                Register scratch) { … }

inline void MaglevAssembler::CompareInstanceType(Register map,
                                                 InstanceType instance_type) { … }

inline void MaglevAssembler::CompareInstanceTypeRange(
    Register map, Register instance_type_out, InstanceType lower_limit,
    InstanceType higher_limit) { … }

inline void MaglevAssembler::CompareFloat64AndJumpIf(
    DoubleRegister src1, DoubleRegister src2, Condition cond, Label* target,
    Label* nan_failed, Label::Distance distance) { … }

inline void MaglevAssembler::CompareFloat64AndBranch(
    DoubleRegister src1, DoubleRegister src2, Condition cond,
    BasicBlock* if_true, BasicBlock* if_false, BasicBlock* next_block,
    BasicBlock* nan_failed) { … }

inline void MaglevAssembler::PrepareCallCFunction(int num_reg_arguments,
                                                  int num_double_registers) { … }

inline void MaglevAssembler::CallSelf() { … }

inline void MaglevAssembler::Jump(Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::JumpToDeopt(Label* target) { … }

inline void MaglevAssembler::EmitEagerDeoptStress(Label* target) { … }

inline void MaglevAssembler::JumpIf(Condition cond, Label* target,
                                    Label::Distance distance) { … }

inline void MaglevAssembler::JumpIfRoot(Register with, RootIndex index,
                                        Label* if_equal,
                                        Label::Distance distance) { … }

inline void MaglevAssembler::JumpIfNotRoot(Register with, RootIndex index,
                                           Label* if_not_equal,
                                           Label::Distance distance) { … }

inline void MaglevAssembler::JumpIfSmi(Register src, Label* on_smi,
                                       Label::Distance distance) { … }

inline void MaglevAssembler::JumpIfNotSmi(Register src, Label* on_not_smi,
                                          Label::Distance distance) { … }

void MaglevAssembler::JumpIfByte(Condition cc, Register value, int32_t byte,
                                 Label* target, Label::Distance distance) { … }

void MaglevAssembler::JumpIfHoleNan(DoubleRegister value, Register scratch,
                                    Label* target, Label::Distance distance) { … }

void MaglevAssembler::JumpIfNotHoleNan(DoubleRegister value, Register scratch,
                                       Label* target,
                                       Label::Distance distance) { … }

void MaglevAssembler::JumpIfNotHoleNan(MemOperand operand, Label* target,
                                       Label::Distance distance) { … }

void MaglevAssembler::JumpIfNan(DoubleRegister value, Label* target,
                                Label::Distance distance) { … }

void MaglevAssembler::JumpIfNotNan(DoubleRegister value, Label* target,
                                   Label::Distance distance) { … }

void MaglevAssembler::CompareInt32AndJumpIf(Register r1, Register r2,
                                            Condition cond, Label* target,
                                            Label::Distance distance) { … }

void MaglevAssembler::CompareIntPtrAndJumpIf(Register r1, Register r2,
                                             Condition cond, Label* target,
                                             Label::Distance distance) { … }

inline void MaglevAssembler::CompareInt32AndJumpIf(Register r1, int32_t value,
                                                   Condition cond,
                                                   Label* target,
                                                   Label::Distance distance) { … }

inline void MaglevAssembler::CompareInt32AndBranch(
    Register r1, int32_t value, Condition cond, Label* if_true,
    Label::Distance true_distance, bool fallthrough_when_true, Label* if_false,
    Label::Distance false_distance, bool fallthrough_when_false) { … }

inline void MaglevAssembler::CompareInt32AndBranch(
    Register r1, Register r2, Condition cond, Label* if_true,
    Label::Distance true_distance, bool fallthrough_when_true, Label* if_false,
    Label::Distance false_distance, bool fallthrough_when_false) { … }

inline void MaglevAssembler::CompareInt32AndAssert(Register r1, Register r2,
                                                   Condition cond,
                                                   AbortReason reason) { … }
inline void MaglevAssembler::CompareInt32AndAssert(Register r1, int32_t value,
                                                   Condition cond,
                                                   AbortReason reason) { … }

inline void MaglevAssembler::CompareSmiAndJumpIf(Register r1, Tagged<Smi> value,
                                                 Condition cond, Label* target,
                                                 Label::Distance distance) { … }

inline void MaglevAssembler::CompareSmiAndAssert(Register r1, Tagged<Smi> value,
                                                 Condition cond,
                                                 AbortReason reason) { … }

inline void MaglevAssembler::CompareByteAndJumpIf(MemOperand left, int8_t right,
                                                  Condition cond,
                                                  Register scratch,
                                                  Label* target,
                                                  Label::Distance distance) { … }

inline void MaglevAssembler::CompareTaggedAndJumpIf(Register r1,
                                                    Tagged<Smi> value,
                                                    Condition cond,
                                                    Label* target,
                                                    Label::Distance distance) { … }

inline void MaglevAssembler::CompareTaggedAndJumpIf(Register r1,
                                                    Handle<HeapObject> obj,
                                                    Condition cond,
                                                    Label* target,
                                                    Label::Distance distance) { … }

inline void MaglevAssembler::CompareTaggedAndJumpIf(Register src1,
                                                    Register src2,
                                                    Condition cond,
                                                    Label* target,
                                                    Label::Distance distance) { … }

inline void MaglevAssembler::CompareDoubleAndJumpIfZeroOrNaN(
    DoubleRegister reg, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::CompareDoubleAndJumpIfZeroOrNaN(
    MemOperand operand, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::TestInt32AndJumpIfAnySet(
    Register r1, int32_t mask, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::TestInt32AndJumpIfAnySet(
    MemOperand operand, int32_t mask, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::TestUint8AndJumpIfAnySet(
    MemOperand operand, uint8_t mask, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::TestInt32AndJumpIfAllClear(
    Register r1, int32_t mask, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::TestInt32AndJumpIfAllClear(
    MemOperand operand, int32_t mask, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::TestUint8AndJumpIfAllClear(
    MemOperand operand, uint8_t mask, Label* target, Label::Distance distance) { … }

inline void MaglevAssembler::LoadHeapNumberValue(DoubleRegister result,
                                                 Register heap_number) { … }

inline void MaglevAssembler::Int32ToDouble(DoubleRegister result,
                                           Register src) { … }

inline void MaglevAssembler::Uint32ToDouble(DoubleRegister result,
                                            Register src) { … }

inline void MaglevAssembler::Pop(Register dst) { … }

template <typename NodeT>
inline void MaglevAssembler::EmitEagerDeoptIfNotEqual(DeoptimizeReason reason,
                                                      NodeT* node) { … }

inline void MaglevAssembler::AssertStackSizeCorrect() { … }

inline Condition MaglevAssembler::FunctionEntryStackCheck(
    int stack_check_offset) { … }

inline void MaglevAssembler::FinishCode() { … }

template <typename Dest, typename Source>
inline void MaglevAssembler::MoveRepr(MachineRepresentation repr, Dest dst,
                                      Source src) { … }
template <>
inline void MaglevAssembler::MoveRepr(MachineRepresentation repr,
                                      MemOperand dst, MemOperand src) { … }

inline void MaglevAssembler::MaybeEmitPlaceHolderForDeopt() { … }

}  // namespace maglev
}  // namespace internal
}  // namespace v8

#endif  // V8_MAGLEV_X64_MAGLEV_ASSEMBLER_X64_INL_H_
chromium/v8/src/maglev/x64/maglev-assembler-x64-inl.h
