maglev-ir-riscv.cc

Go to the documentation of this file.

// Copyright 2024 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.
 
#include "src/base/logging.h"
#include "src/codegen/interface-descriptors-inl.h"
#include "src/codegen/riscv/assembler-riscv-inl.h"
#include "src/codegen/riscv/register-riscv.h"
#include "src/maglev/maglev-assembler-inl.h"
#include "src/maglev/maglev-graph-processor.h"
#include "src/maglev/maglev-graph.h"
#include "src/maglev/maglev-ir-inl.h"
#include "src/maglev/maglev-ir.h"
#include "src/maglev/riscv/maglev-assembler-riscv-inl.h"
#include "src/objects/feedback-cell.h"
#include "src/objects/js-function.h"
 
namespace v8 {
namespace internal {
namespace maglev {
 
#define __ masm->
 
void Int32NegateWithOverflow::SetValueLocationConstraints() {
  UseRegister(value_input());
  DefineAsRegister(this);
}
 
void Int32NegateWithOverflow::GenerateCode(MaglevAssembler* masm,
                                           const ProcessingState& state) {
  Register value = ToRegister(value_input());
  Register out = ToRegister(result());
 
  static_assert(Int32NegateWithOverflow::kProperties.can_eager_deopt());
  // Deopt when result would be -0.
  Label* fail = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, equal, value, Operand(zero_reg));
 
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  __ neg(scratch, value);
  __ negw(out, value);
 
  // Are the results of NEG and NEGW on the operand different?
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, not_equal, scratch, Operand(out));
 
  // Output register must not be a register input into the eager deopt info.
  DCHECK_REGLIST_EMPTY(RegList{out} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
}
 
void Int32AbsWithOverflow::GenerateCode(MaglevAssembler* masm,
                                        const ProcessingState& state) {
  Register out = ToRegister(result());
 
  static_assert(Int32AbsWithOverflow::kProperties.can_eager_deopt());
  Label done;
  DCHECK(ToRegister(input()) == out);
  // fast-path
  __ MacroAssembler::Branch(&done, greater_equal, out, Operand(zero_reg),
                            Label::Distance::kNear);
 
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  __ neg(scratch, out);
  __ negw(out, out);
 
  // Are the results of NEG and NEGW on the operand different?
  Label* fail = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, not_equal, scratch, Operand(out));
 
  __ bind(&done);
 
  // Output register must not be a register input into the eager deopt info.
  DCHECK_REGLIST_EMPTY(RegList{out} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
}
 
void Int32IncrementWithOverflow::SetValueLocationConstraints() {
  UseRegister(value_input());
  DefineAsRegister(this);
}
 
void Int32IncrementWithOverflow::GenerateCode(MaglevAssembler* masm,
                                              const ProcessingState& state) {
  Register value = ToRegister(value_input());
  Register out = ToRegister(result());
 
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  __ Add32(scratch, value, Operand(1));
 
  static_assert(Int32IncrementWithOverflow::kProperties.can_eager_deopt());
  Label* fail = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, less, scratch, Operand(value));
  __ Mv(out, scratch);
 
  // Output register must not be a register input into the eager deopt info.
  DCHECK_REGLIST_EMPTY(RegList{out} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
}
 
void Int32DecrementWithOverflow::SetValueLocationConstraints() {
  UseRegister(value_input());
  DefineAsRegister(this);
}
 
void Int32DecrementWithOverflow::GenerateCode(MaglevAssembler* masm,
                                              const ProcessingState& state) {
  Register value = ToRegister(value_input());
  Register out = ToRegister(result());
 
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  __ Sub32(scratch, value, Operand(1));
 
  static_assert(Int32DecrementWithOverflow::kProperties.can_eager_deopt());
  Label* fail = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, greater, scratch, Operand(value));
  __ Mv(out, scratch);
 
  // Output register must not be a register input into the eager deopt info.
  DCHECK_REGLIST_EMPTY(RegList{out} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
}
 
int BuiltinStringFromCharCode::MaxCallStackArgs() const {
  return AllocateDescriptor::GetStackParameterCount();
}
void BuiltinStringFromCharCode::SetValueLocationConstraints() {
  if (code_input().node()->Is<Int32Constant>()) {
    UseAny(code_input());
  } else {
    UseRegister(code_input());
  }
  set_temporaries_needed(2);
  DefineAsRegister(this);
}
void BuiltinStringFromCharCode::GenerateCode(MaglevAssembler* masm,
                                             const ProcessingState& state) {
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.Acquire();
  Register result_string = ToRegister(result());
  if (Int32Constant* constant = code_input().node()->TryCast<Int32Constant>()) {
    int32_t char_code = constant->value() & 0xFFFF;
    if (0 <= char_code && char_code < String::kMaxOneByteCharCode) {
      __ LoadSingleCharacterString(result_string, char_code);
    } else {
      __ AllocateTwoByteString(register_snapshot(), result_string, 1);
      __ Move(scratch, char_code);
      __ Sh(scratch, FieldMemOperand(result_string,
                                     OFFSET_OF_DATA_START(SeqTwoByteString)));
    }
  } else {
    __ StringFromCharCode(register_snapshot(), nullptr, result_string,
                          ToRegister(code_input()), scratch,
                          MaglevAssembler::CharCodeMaskMode::kMustApplyMask);
  }
}
 
void InlinedAllocation::SetValueLocationConstraints() {
  UseRegister(allocation_block_input());
  if (offset() == 0) {
    DefineSameAsFirst(this);
  } else {
    DefineAsRegister(this);
  }
}
 
void InlinedAllocation::GenerateCode(MaglevAssembler* masm,
                                     const ProcessingState& state) {
  Register out = ToRegister(result());
  Register value = ToRegister(allocation_block_input());
  if (offset() != 0) {
    __ AddWord(out, value, Operand(offset()));
  }
}
 
void ArgumentsLength::SetValueLocationConstraints() { DefineAsRegister(this); }
 
void ArgumentsLength::GenerateCode(MaglevAssembler* masm,
                                   const ProcessingState& state) {
  Register out = ToRegister(result());
 
  __ LoadWord(out, MemOperand(fp, StandardFrameConstants::kArgCOffset));
  __ Sub64(out, out, Operand(1));  // Remove receiver.
}
 
void RestLength::SetValueLocationConstraints() { DefineAsRegister(this); }
 
void RestLength::GenerateCode(MaglevAssembler* masm,
                              const ProcessingState& state) {
  Register length = ToRegister(result());
  Label done;
  __ LoadWord(length, MemOperand(fp, StandardFrameConstants::kArgCOffset));
  __ Sub64(length, length, Operand(formal_parameter_count() + 1));
  __ MacroAssembler::Branch(&done, greater_equal, length, Operand(zero_reg),
                            Label::Distance::kNear);
  __ Mv(length, zero_reg);
  __ bind(&done);
  __ UncheckedSmiTagInt32(length);
}
 
int CheckedObjectToIndex::MaxCallStackArgs() const { return 0; }
 
void CheckedIntPtrToInt32::SetValueLocationConstraints() {
  UseRegister(input());
  DefineSameAsFirst(this);
}
 
void CheckedIntPtrToInt32::GenerateCode(MaglevAssembler* masm,
                                        const ProcessingState& state) {
  Register input_reg = ToRegister(input());
  __ MacroAssembler::Branch(__ GetDeoptLabel(this, DeoptimizeReason::kNotInt32),
                            gt, input_reg,
                            Operand(std::numeric_limits<int32_t>::max()));
  __ MacroAssembler::Branch(__ GetDeoptLabel(this, DeoptimizeReason::kNotInt32),
                            lt, input_reg,
                            Operand(std::numeric_limits<int32_t>::min()));
}
 
void Int32AddWithOverflow::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
}
 
void Int32AddWithOverflow::GenerateCode(MaglevAssembler* masm,
                                        const ProcessingState& state) {
  Register left = ToRegister(left_input());
  Register right = ToRegister(right_input());
  Register out = ToRegister(result());
 
  static_assert(Int32AddWithOverflow::kProperties.can_eager_deopt());
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  Label* fail = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
  __ Add64(scratch, left, right);
  __ Add32(out, left, right);
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, not_equal, scratch, Operand(out));
 
  // The output register shouldn't be a register input into the eager deopt
  // info.
  DCHECK_REGLIST_EMPTY(RegList{out} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
}
 
void Int32SubtractWithOverflow::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
}
void Int32SubtractWithOverflow::GenerateCode(MaglevAssembler* masm,
                                             const ProcessingState& state) {
  Register left = ToRegister(left_input());
  Register right = ToRegister(right_input());
  Register out = ToRegister(result());
 
  static_assert(Int32SubtractWithOverflow::kProperties.can_eager_deopt());
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  Label* fail = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
  __ Sub64(scratch, left, right);
  __ Sub32(out, left, right);
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, ne, scratch, Operand(out));
 
  // The output register shouldn't be a register input into the eager deopt
  // info.
  DCHECK_REGLIST_EMPTY(RegList{out} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
}
 
void Int32MultiplyWithOverflow::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
  set_temporaries_needed(2);
}
void Int32MultiplyWithOverflow::GenerateCode(MaglevAssembler* masm,
                                             const ProcessingState& state) {
  Register left = ToRegister(left_input());
  Register right = ToRegister(right_input());
  Register out = ToRegister(result());
 
  // TODO(leszeks): peephole optimise multiplication by a constant.
 
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  bool out_alias_input = out == left || out == right;
  Register res = out;
  if (out_alias_input) {
    res = temps.Acquire();
  }
 
  Register scratch = temps.Acquire();
  __ MulOverflow32(res, left, Operand(right), scratch, false);
 
  static_assert(Int32MultiplyWithOverflow::kProperties.can_eager_deopt());
  // if res != (res[0:31] sign extended to 64 bits), then the multiplication
  // result is too large for 32 bits.
  Label* fail = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
  __ RecordComment("-- Jump to eager deopt");
  __ MacroAssembler::Branch(fail, ne, scratch, Operand(zero_reg));
 
  // If the result is zero, check if either lhs or rhs is negative.
  Label end;
  __ MacroAssembler::Branch(&end, ne, res, Operand(zero_reg),
                            Label::Distance::kNear);
  {
    Register maybeNegative = scratch;
    __ Or(maybeNegative, left, Operand(right));
    // TODO(Vladimir Kempik): consider usage of bexti instruction if Zbs
    // extension is available
    __ And(maybeNegative, maybeNegative, Operand(0x80000000));  // 1 << 31
    // If one of them is negative, we must have a -0 result, which is non-int32,
    // so deopt.
    // TODO(leszeks): Consider splitting these deopts to have distinct deopt
    // reasons. Otherwise, the reason has to match the above.
    __ RecordComment("-- Jump to eager deopt if the result is negative zero");
    Label* deopt_label = __ GetDeoptLabel(this, DeoptimizeReason::kOverflow);
    __ MacroAssembler::Branch(deopt_label, ne, maybeNegative,
                              Operand(zero_reg));
  }
 
  __ bind(&end);
  if (out_alias_input) {
    __ Move(out, res);
  }
 
  // The output register shouldn't be a register input into the eager deopt
  // info.
  DCHECK_REGLIST_EMPTY(RegList{out} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
}
 
void Int32DivideWithOverflow::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
  set_temporaries_needed(2);
}
void Int32DivideWithOverflow::GenerateCode(MaglevAssembler* masm,
                                           const ProcessingState& state) {
  Register left = ToRegister(left_input());
  Register right = ToRegister(right_input());
  Register out = ToRegister(result());
 
  // TODO(leszeks): peephole optimise division by a constant.
 
  static_assert(Int32DivideWithOverflow::kProperties.can_eager_deopt());
  ZoneLabelRef done(masm);
  Label* deferred_overflow_checks = __ MakeDeferredCode(
      [](MaglevAssembler* masm, ZoneLabelRef done, Register left,
         Register right, Int32DivideWithOverflow* node) {
        // {right} is negative or zero.
 
        // TODO(leszeks): Using kNotInt32 here, but in same places
        // kDivisionByZerokMinusZero/kMinusZero/kOverflow would be better. Right
        // now all eager deopts in a node have to be the same -- we should allow
        // a node to emit multiple eager deopts with different reasons.
        Label* deopt = __ GetDeoptLabel(node, DeoptimizeReason::kNotInt32);
 
        // Check if {right} is zero.
        __ RecordComment("-- Jump to eager deopt if right is zero");
        __ MacroAssembler::Branch(deopt, eq, right, Operand(zero_reg));
 
        // Check if {left} is zero, as that would produce minus zero.
        __ RecordComment("-- Jump to eager deopt if left is zero");
        __ MacroAssembler::Branch(deopt, eq, left, Operand(zero_reg));
 
        // Check if {left} is kMinInt and {right} is -1, in which case we'd have
        // to return -kMinInt, which is not representable as Int32.
        __ MacroAssembler::Branch(*done, ne, left, Operand(kMinInt));
        __ MacroAssembler::Branch(*done, ne, right, Operand(-1));
        __ JumpToDeopt(deopt);
      },
      done, left, right, this);
 
  // Check if {right} is positive and not zero.
  __ MacroAssembler::Branch(deferred_overflow_checks, less_equal, right,
                            Operand(zero_reg));
  __ bind(*done);
 
  // Perform the actual integer division.
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  bool out_alias_input = out == left || out == right;
  Register res = out;
  if (out_alias_input) {
    res = temps.Acquire();
  }
  __ Div32(res, left, right);
 
  // Check that the remainder is zero.
  Register temp = temps.Acquire();
  __ remw(temp, left, right);
  Label* deopt = __ GetDeoptLabel(this, DeoptimizeReason::kNotInt32);
  __ RecordComment("-- Jump to eager deopt if remainder is zero");
  __ MacroAssembler::Branch(deopt, ne, temp, Operand(zero_reg));
 
  // The output register shouldn't be a register input into the eager deopt
  // info.
  DCHECK_REGLIST_EMPTY(RegList{res} &
                       GetGeneralRegistersUsedAsInputs(eager_deopt_info()));
  __ Move(out, res);
}
 
void Int32ModulusWithOverflow::SetValueLocationConstraints() {
  UseAndClobberRegister(left_input());
  UseAndClobberRegister(right_input());
  DefineAsRegister(this);
  set_temporaries_needed(1);
}
void Int32ModulusWithOverflow::GenerateCode(MaglevAssembler* masm,
                                            const ProcessingState& state) {
  // If AreAliased(lhs, rhs):
  //   deopt if lhs < 0  // Minus zero.
  //   0
  //
  // Using same algorithm as in EffectControlLinearizer:
  //   if rhs <= 0 then
  //     rhs = -rhs
  //     deopt if rhs == 0
  //   if lhs < 0 then
  //     let lhs_abs = -lhs in
  //     let res = lhs_abs % rhs in
  //     deopt if res == 0
  //     -res
  //   else
  //     let msk = rhs - 1 in
  //     if rhs & msk == 0 then
  //       lhs & msk
  //     else
  //       lhs % rhs
 
  Register lhs = ToRegister(left_input());
  Register rhs = ToRegister(right_input());
  Register out = ToRegister(result());
 
  static_assert(Int32ModulusWithOverflow::kProperties.can_eager_deopt());
  static constexpr DeoptimizeReason deopt_reason =
      DeoptimizeReason::kDivisionByZero;
 
  // For the modulus algorithm described above, lhs and rhs must not alias
  // each other.
  if (lhs == rhs) {
    // TODO(victorgomes): This ideally should be kMinusZero, but Maglev only
    // allows one deopt reason per IR.
    Label* deopt = __ GetDeoptLabel(this, DeoptimizeReason::kDivisionByZero);
    __ RecordComment("-- Jump to eager deopt");
    __ MacroAssembler::Branch(deopt, less, lhs, Operand(zero_reg));
    __ Move(out, zero_reg);
    return;
  }
 
  DCHECK(!AreAliased(lhs, rhs));
 
  ZoneLabelRef done(masm);
  ZoneLabelRef rhs_checked(masm);
 
  Label* deferred_rhs_check = __ MakeDeferredCode(
      [](MaglevAssembler* masm, ZoneLabelRef rhs_checked, Register rhs,
         Int32ModulusWithOverflow* node) {
        __ negw(rhs, rhs);
        __ MacroAssembler::Branch(*rhs_checked, ne, rhs, Operand(zero_reg));
        __ EmitEagerDeopt(node, deopt_reason);
      },
      rhs_checked, rhs, this);
  __ MacroAssembler::Branch(deferred_rhs_check, less_equal, rhs,
                            Operand(zero_reg));
  __ bind(*rhs_checked);
 
  Label* deferred_lhs_check = __ MakeDeferredCode(
      [](MaglevAssembler* masm, ZoneLabelRef done, Register lhs, Register rhs,
         Register out, Int32ModulusWithOverflow* node) {
        MaglevAssembler::TemporaryRegisterScope temps(masm);
        Register lhs_abs = temps.AcquireScratch();
        __ negw(lhs_abs, lhs);
        Register res = lhs_abs;
        __ remw(res, lhs_abs, rhs);
        __ negw(out, res);
        __ MacroAssembler::Branch(*done, ne, res, Operand(zero_reg));
        // TODO(victorgomes): This ideally should be kMinusZero, but Maglev
        // only allows one deopt reason per IR.
        __ EmitEagerDeopt(node, deopt_reason);
      },
      done, lhs, rhs, out, this);
  __ MacroAssembler::Branch(deferred_lhs_check, less, lhs, Operand(zero_reg));
 
  Label rhs_not_power_of_2;
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  Register msk = temps.AcquireScratch();
  __ Sub32(msk, rhs, Operand(1));
  __ And(scratch, rhs, msk);
  __ MacroAssembler::Branch(&rhs_not_power_of_2, not_equal, scratch,
                            Operand(zero_reg), Label::kNear);
  // {rhs} is power of 2.
  __ And(out, lhs, msk);
  __ MacroAssembler::Branch(*done, Label::kNear);
 
  __ bind(&rhs_not_power_of_2);
  __ remw(out, lhs, rhs);
 
  __ bind(*done);
}
 
#define DEF_BITWISE_BINOP(Instruction, opcode)                   \
  void Instruction::SetValueLocationConstraints() {              \
    UseRegister(left_input());                                   \
    UseRegister(right_input());                                  \
    DefineAsRegister(this);                                      \
  }                                                              \
                                                                 \
  void Instruction::GenerateCode(MaglevAssembler* masm,          \
                                 const ProcessingState& state) { \
    Register lhs = ToRegister(left_input());                     \
    Register rhs = ToRegister(right_input());                    \
    Register out = ToRegister(result());                         \
    __ opcode(out, lhs, Operand(rhs));                           \
    /* TODO: is zero extension really needed here? */            \
    __ ZeroExtendWord(out, out);                                 \
  }
DEF_BITWISE_BINOP(Int32BitwiseAnd, And)
DEF_BITWISE_BINOP(Int32BitwiseOr, Or)
DEF_BITWISE_BINOP(Int32BitwiseXor, Xor)
#undef DEF_BITWISE_BINOP
 
#define DEF_SHIFT_BINOP(Instruction, opcode)                     \
  void Instruction::SetValueLocationConstraints() {              \
    UseRegister(left_input());                                   \
    if (right_input().node()->Is<Int32Constant>()) {             \
      UseAny(right_input());                                     \
    } else {                                                     \
      UseRegister(right_input());                                \
    }                                                            \
    DefineAsRegister(this);                                      \
  }                                                              \
                                                                 \
  void Instruction::GenerateCode(MaglevAssembler* masm,          \
                                 const ProcessingState& state) { \
    Register out = ToRegister(result());                         \
    Register lhs = ToRegister(left_input());                     \
    if (Int32Constant* constant =                                \
            right_input().node()->TryCast<Int32Constant>()) {    \
      uint32_t shift = constant->value() & 31;                   \
      if (shift == 0) {                                          \
        __ ZeroExtendWord(out, lhs);                             \
        return;                                                  \
      }                                                          \
      __ opcode(out, lhs, Operand(shift));                       \
    } else {                                                     \
      Register rhs = ToRegister(right_input());                  \
      __ opcode(out, lhs, Operand(rhs));                         \
    }                                                            \
  }
DEF_SHIFT_BINOP(Int32ShiftLeft, Sll32)
DEF_SHIFT_BINOP(Int32ShiftRight, Sra32)
DEF_SHIFT_BINOP(Int32ShiftRightLogical, Srl32)
#undef DEF_SHIFT_BINOP
 
void Int32BitwiseNot::SetValueLocationConstraints() {
  UseRegister(value_input());
  DefineAsRegister(this);
}
 
void Int32BitwiseNot::GenerateCode(MaglevAssembler* masm,
                                   const ProcessingState& state) {
  Register value = ToRegister(value_input());
  Register out = ToRegister(result());
  __ not_(out, value);
  __ ZeroExtendWord(out, out);  // TODO(Yuri Gaevsky): is it really needed?
}
 
void Float64Add::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
}
 
void Float64Add::GenerateCode(MaglevAssembler* masm,
                              const ProcessingState& state) {
  DoubleRegister left = ToDoubleRegister(left_input());
  DoubleRegister right = ToDoubleRegister(right_input());
  DoubleRegister out = ToDoubleRegister(result());
  __ fadd_d(out, left, right);
}
 
void Float64Subtract::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
}
 
void Float64Subtract::GenerateCode(MaglevAssembler* masm,
                                   const ProcessingState& state) {
  DoubleRegister left = ToDoubleRegister(left_input());
  DoubleRegister right = ToDoubleRegister(right_input());
  DoubleRegister out = ToDoubleRegister(result());
  __ fsub_d(out, left, right);
}
 
void Float64Multiply::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
}
 
void Float64Multiply::GenerateCode(MaglevAssembler* masm,
                                   const ProcessingState& state) {
  DoubleRegister left = ToDoubleRegister(left_input());
  DoubleRegister right = ToDoubleRegister(right_input());
  DoubleRegister out = ToDoubleRegister(result());
  __ fmul_d(out, left, right);
}
 
void Float64Divide::SetValueLocationConstraints() {
  UseRegister(left_input());
  UseRegister(right_input());
  DefineAsRegister(this);
}
 
void Float64Divide::GenerateCode(MaglevAssembler* masm,
                                 const ProcessingState& state) {
  DoubleRegister left = ToDoubleRegister(left_input());
  DoubleRegister right = ToDoubleRegister(right_input());
  DoubleRegister out = ToDoubleRegister(result());
  __ fdiv_d(out, left, right);
}
 
int Float64Modulus::MaxCallStackArgs() const { return 0; }
void Float64Modulus::SetValueLocationConstraints() {
  UseFixed(left_input(), fa0);
  UseFixed(right_input(), fa1);
  DefineSameAsFirst(this);
}
void Float64Modulus::GenerateCode(MaglevAssembler* masm,
                                  const ProcessingState& state) {
  AllowExternalCallThatCantCauseGC scope(masm);
  __ PrepareCallCFunction(0, 2);
  __ CallCFunction(ExternalReference::mod_two_doubles_operation(), 0, 2);
}
 
void Float64Negate::SetValueLocationConstraints() {
  UseRegister(input());
  DefineAsRegister(this);
}
void Float64Negate::GenerateCode(MaglevAssembler* masm,
                                 const ProcessingState& state) {
  DoubleRegister value = ToDoubleRegister(input());
  DoubleRegister out = ToDoubleRegister(result());
  __ fneg_d(out, value);
}
 
void Float64Abs::GenerateCode(MaglevAssembler* masm,
                              const ProcessingState& state) {
  DoubleRegister in = ToDoubleRegister(input());
  DoubleRegister out = ToDoubleRegister(result());
  __ fabs_d(out, in);
}
 
void Float64Round::GenerateCode(MaglevAssembler* masm,
                                const ProcessingState& state) {
  DoubleRegister in = ToDoubleRegister(input());
  DoubleRegister out = ToDoubleRegister(result());
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  DoubleRegister fscratch1 = temps.AcquireScratchDouble();
 
  if (kind_ == Kind::kNearest) {
    // RISC-V Rounding Mode RNE means "Round to Nearest, ties to Even", while JS
    // expects it to round towards +Infinity (see ECMA-262, 20.2.2.28).
    // The best seems to be to add 0.5 then round with RDN mode.
 
    DoubleRegister half_one = temps.AcquireDouble();  // available in this mode
    __ LoadFPRImmediate(half_one, 0.5);
    DoubleRegister tmp = half_one;
    __ fadd_d(tmp, in, half_one);
    __ Floor_d_d(out, tmp, fscratch1);
    __ fsgnj_d(out, out, in);
  } else if (kind_ == Kind::kCeil) {
    __ Ceil_d_d(out, in, fscratch1);
  } else if (kind_ == Kind::kFloor) {
    __ Floor_d_d(out, in, fscratch1);
  } else {
    UNREACHABLE();
  }
}
 
int Float64Exponentiate::MaxCallStackArgs() const { return 0; }
void Float64Exponentiate::SetValueLocationConstraints() {
  UseFixed(left_input(), fa0);
  UseFixed(right_input(), fa1);
  DefineSameAsFirst(this);
}
void Float64Exponentiate::GenerateCode(MaglevAssembler* masm,
                                       const ProcessingState& state) {
  AllowExternalCallThatCantCauseGC scope(masm);
  __ PrepareCallCFunction(0, 2);
  __ CallCFunction(ExternalReference::ieee754_pow_function(), 2);
}
 
int Float64Ieee754Unary::MaxCallStackArgs() const { return 0; }
void Float64Ieee754Unary::SetValueLocationConstraints() {
  UseFixed(input(), fa0);
  DefineSameAsFirst(this);
}
void Float64Ieee754Unary::GenerateCode(MaglevAssembler* masm,
                                       const ProcessingState& state) {
  AllowExternalCallThatCantCauseGC scope(masm);
  __ PrepareCallCFunction(0, 1);
  __ CallCFunction(ieee_function_ref(), 1);
}
 
void LoadTypedArrayLength::SetValueLocationConstraints() {
  UseRegister(receiver_input());
  DefineAsRegister(this);
}
void LoadTypedArrayLength::GenerateCode(MaglevAssembler* masm,
                                        const ProcessingState& state) {
  Register object = ToRegister(receiver_input());
  Register result_register = ToRegister(result());
  if (v8_flags.debug_code) {
    __ AssertObjectType(object, JS_TYPED_ARRAY_TYPE,
                        AbortReason::kUnexpectedValue);
  }
  __ LoadBoundedSizeFromObject(result_register, object,
                               JSTypedArray::kRawByteLengthOffset);
  int shift_size = ElementsKindToShiftSize(elements_kind_);
  if (shift_size > 0) {
    // TODO(leszeks): Merge this shift with the one in LoadBoundedSize.
    DCHECK(shift_size == 1 || shift_size == 2 || shift_size == 3);
    __ SrlWord(result_register, result_register, Operand(shift_size));
  }
}
 
int CheckJSDataViewBounds::MaxCallStackArgs() const { return 1; }
void CheckJSDataViewBounds::SetValueLocationConstraints() {
  UseRegister(receiver_input());
  UseRegister(index_input());
  set_temporaries_needed(1);
}
void CheckJSDataViewBounds::GenerateCode(MaglevAssembler* masm,
                                         const ProcessingState& state) {
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register object = ToRegister(receiver_input());
  Register index = ToRegister(index_input());
  if (v8_flags.debug_code) {
    __ AssertObjectType(object, JS_DATA_VIEW_TYPE,
                        AbortReason::kUnexpectedValue);
  }
 
  // Normal DataView (backed by AB / SAB) or non-length tracking backed by GSAB.
  Register byte_length = temps.Acquire();
  __ LoadBoundedSizeFromObject(byte_length, object,
                               JSDataView::kRawByteLengthOffset);
 
  int element_size = compiler::ExternalArrayElementSize(element_type_);
  Label ok;
  if (element_size > 1) {
    __ SubWord(byte_length, byte_length, Operand(element_size - 1));
    __ MacroAssembler::Branch(&ok, ge, byte_length, Operand(zero_reg),
                              Label::Distance::kNear);
    __ EmitEagerDeopt(this, DeoptimizeReason::kOutOfBounds);
  }
  __ MacroAssembler::Branch(&ok, ult, index, Operand(byte_length),
                            Label::Distance::kNear);
  __ EmitEagerDeopt(this, DeoptimizeReason::kOutOfBounds);
 
  __ bind(&ok);
}
 
void HoleyFloat64ToMaybeNanFloat64::SetValueLocationConstraints() {
  UseRegister(input());
  DefineAsRegister(this);
}
void HoleyFloat64ToMaybeNanFloat64::GenerateCode(MaglevAssembler* masm,
                                                 const ProcessingState& state) {
  // The hole value is a signalling NaN, so just silence it to get the float64
  // value.
  __ FPUCanonicalizeNaN(ToDoubleRegister(result()), ToDoubleRegister(input()));
}
 
namespace {
 
enum class ReduceInterruptBudgetType { kLoop, kReturn };
 
void HandleInterruptsAndTiering(MaglevAssembler* masm, ZoneLabelRef done,
                                Node* node, ReduceInterruptBudgetType type,
                                Register scratch0) {
  // For loops, first check for interrupts. Don't do this for returns, as we
  // can't lazy deopt to the end of a return.
  if (type == ReduceInterruptBudgetType::kLoop) {
    Label next;
    // Here, we only care about interrupts since we've already guarded against
    // real stack overflows on function entry.
    {
      Register stack_limit = scratch0;
      __ LoadStackLimit(stack_limit, StackLimitKind::kInterruptStackLimit);
      __ MacroAssembler::Branch(&next, ugt, sp, Operand(stack_limit),
                                Label::Distance::kNear);
    }
 
    // An interrupt has been requested and we must call into runtime to handle
    // it; since we already pay the call cost, combine with the TieringManager
    // call.
    {
      SaveRegisterStateForCall save_register_state(masm,
                                                   node->register_snapshot());
      Register function = scratch0;
      __ LoadWord(function,
                  MemOperand(fp, StandardFrameConstants::kFunctionOffset));
      __ Push(function);
      // Move into kContextRegister after the load into scratch0, just in case
      // scratch0 happens to be kContextRegister.
      __ Move(kContextRegister, masm->native_context().object());
      __ CallRuntime(Runtime::kBytecodeBudgetInterruptWithStackCheck_Maglev, 1);
      save_register_state.DefineSafepointWithLazyDeopt(node->lazy_deopt_info());
    }
    __ MacroAssembler::Branch(*done);  // All done, continue.
    __ bind(&next);
  }
 
  // No pending interrupts. Call into the TieringManager if needed.
  {
    SaveRegisterStateForCall save_register_state(masm,
                                                 node->register_snapshot());
    Register function = scratch0;
    __ LoadWord(function,
                MemOperand(fp, StandardFrameConstants::kFunctionOffset));
    __ Push(function);
    // Move into kContextRegister after the load into scratch0, just in case
    // scratch0 happens to be kContextRegister.
    __ Move(kContextRegister, masm->native_context().object());
    // Note: must not cause a lazy deopt!
    __ CallRuntime(Runtime::kBytecodeBudgetInterrupt_Maglev, 1);
    save_register_state.DefineSafepoint();
  }
  __ MacroAssembler::Branch(*done);
}
 
void GenerateReduceInterruptBudget(MaglevAssembler* masm, Node* node,
                                   Register feedback_cell,
                                   ReduceInterruptBudgetType type, int amount) {
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.Acquire();
  Register budget = scratch;
 
  __ Lw(budget,
        FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
  __ Sub32(budget, budget, Operand(amount));
  __ Sw(budget,
        FieldMemOperand(feedback_cell, FeedbackCell::kInterruptBudgetOffset));
 
  ZoneLabelRef done(masm);
  Label* deferred_code = __ MakeDeferredCode(
      [](MaglevAssembler* masm, ZoneLabelRef done, Node* node,
         ReduceInterruptBudgetType type, Register scratch) {
        HandleInterruptsAndTiering(masm, done, node, type, scratch);
      },
      done, node, type, scratch);
  __ MacroAssembler::Branch(deferred_code, lt, budget, Operand(zero_reg));
 
  __ bind(*done);
}
 
}  // namespace
 
int ReduceInterruptBudgetForLoop::MaxCallStackArgs() const { return 1; }
void ReduceInterruptBudgetForLoop::SetValueLocationConstraints() {
  UseRegister(feedback_cell());
  set_temporaries_needed(1);
}
void ReduceInterruptBudgetForLoop::GenerateCode(MaglevAssembler* masm,
                                                const ProcessingState& state) {
  GenerateReduceInterruptBudget(masm, this, ToRegister(feedback_cell()),
                                ReduceInterruptBudgetType::kLoop, amount());
}
 
int ReduceInterruptBudgetForReturn::MaxCallStackArgs() const { return 1; }
void ReduceInterruptBudgetForReturn::SetValueLocationConstraints() {
  UseRegister(feedback_cell());
  set_temporaries_needed(1);
}
void ReduceInterruptBudgetForReturn::GenerateCode(
    MaglevAssembler* masm, const ProcessingState& state) {
  GenerateReduceInterruptBudget(masm, this, ToRegister(feedback_cell()),
                                ReduceInterruptBudgetType::kReturn, amount());
}
 
// ---
// Control nodes
// ---
void Return::SetValueLocationConstraints() {
  UseFixed(value_input(), kReturnRegister0);
}
 
void Return::GenerateCode(MaglevAssembler* masm, const ProcessingState& state) {
  DCHECK_EQ(ToRegister(value_input()), kReturnRegister0);
  // Read the formal number of parameters from the top level compilation unit
  // (i.e. the outermost, non inlined function).
  int formal_params_size =
      masm->compilation_info()->toplevel_compilation_unit()->parameter_count();
 
  // We're not going to continue execution, so we can use an arbitrary register
  // here instead of relying on temporaries from the register allocator.
  // We cannot use scratch registers, since they're used in LeaveFrame and
  // DropArguments.
  Register actual_params_size = a5;
 
  // Compute the size of the actual parameters + receiver (in bytes).
  // TODO(leszeks): Consider making this an input into Return to reuse the
  // incoming argc's register (if it's still valid).
  __ LoadWord(actual_params_size,
              MemOperand(fp, StandardFrameConstants::kArgCOffset));
 
  // Leave the frame.
  __ LeaveFrame(StackFrame::MAGLEV);
 
  // If actual is bigger than formal, then we should use it to free up the stack
  // arguments.
  Label corrected_args_count;
  __ MacroAssembler::Branch(&corrected_args_count, gt, actual_params_size,
                            Operand(formal_params_size),
                            Label::Distance::kNear);
  __ Move(actual_params_size, formal_params_size);
 
  __ bind(&corrected_args_count);
  // Drop receiver + arguments according to dynamic arguments size.
  __ DropArguments(actual_params_size);
  __ Ret();
}
 
}  // namespace maglev
}  // namespace internal
}  // namespace v8