maglev-assembler-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/codegen/interface-descriptors-inl.h"
#include "src/deoptimizer/deoptimizer.h"
#include "src/maglev/maglev-assembler-inl.h"
#include "src/maglev/maglev-graph.h"
namespace v8 {
namespace internal {
namespace maglev {
 
#define __ masm->
 
void SubSizeAndTagObject(MaglevAssembler* masm, Register object,
                         Register size_in_bytes) {
  __ SubWord(object, object, Operand(size_in_bytes));
  __ AddWord(object, object, Operand(kHeapObjectTag));
}
 
void SubSizeAndTagObject(MaglevAssembler* masm, Register object,
                         int size_in_bytes) {
  __ AddWord(object, object, Operand(kHeapObjectTag - size_in_bytes));
}
 
template <typename T>
void AllocateRaw(MaglevAssembler* masm, Isolate* isolate,
                 RegisterSnapshot register_snapshot, Register object,
                 T size_in_bytes, AllocationType alloc_type,
                 AllocationAlignment alignment) {
  DCHECK(masm->allow_allocate());
  // TODO(victorgomes): Call the runtime for large object allocation.
  // TODO(victorgomes): Support double alignment.
  DCHECK_EQ(alignment, kTaggedAligned);
  if (v8_flags.single_generation) {
    alloc_type = AllocationType::kOld;
  }
  ExternalReference top = SpaceAllocationTopAddress(isolate, alloc_type);
  ExternalReference limit = SpaceAllocationLimitAddress(isolate, alloc_type);
 
  ZoneLabelRef done(masm);
  MaglevAssembler::TemporaryRegisterScope temps(masm);
  Register scratch = temps.AcquireScratch();
  // We are a bit short on registers, so we use the same register for {object}
  // and {new_top}. Once we have defined {new_top}, we don't use {object} until
  // {new_top} is used for the last time. And there (at the end of this
  // function), we recover the original {object} from {new_top} by subtracting
  // {size_in_bytes}.
  Register new_top = object;
  // Check if there is enough space.
  __ LoadWord(object, __ ExternalReferenceAsOperand(top, scratch));
  __ AddWord(new_top, object, Operand(size_in_bytes));
  __ LoadWord(scratch, __ ExternalReferenceAsOperand(limit, scratch));
 
  // Call runtime if new_top >= limit.
  __ MacroAssembler::Branch(
      __ MakeDeferredCode(
          [](MaglevAssembler* masm, RegisterSnapshot register_snapshot,
             Register object, AllocationType alloc_type, T size_in_bytes,
             ZoneLabelRef done) {
            AllocateSlow(masm, register_snapshot, object,
                         AllocateBuiltin(alloc_type), size_in_bytes, done);
          },
          register_snapshot, object, alloc_type, size_in_bytes, done),
      ge, new_top, Operand(scratch));
 
  // Store new top and tag object.
  __ Move(__ ExternalReferenceAsOperand(top, scratch), new_top);
  SubSizeAndTagObject(masm, object, size_in_bytes);
  __ bind(*done);
}
 
void MaglevAssembler::Allocate(RegisterSnapshot register_snapshot,
                               Register object, int size_in_bytes,
                               AllocationType alloc_type,
                               AllocationAlignment alignment) {
  AllocateRaw(this, isolate_, register_snapshot, object, size_in_bytes,
              alloc_type, alignment);
}
 
void MaglevAssembler::Allocate(RegisterSnapshot register_snapshot,
                               Register object, Register size_in_bytes,
                               AllocationType alloc_type,
                               AllocationAlignment alignment) {
  AllocateRaw(this, isolate_, register_snapshot, object, size_in_bytes,
              alloc_type, alignment);
}
 
void MaglevAssembler::OSRPrologue(Graph* graph) {
  DCHECK(graph->is_osr());
  CHECK(!graph->has_recursive_calls());
 
  uint32_t source_frame_size =
      graph->min_maglev_stackslots_for_unoptimized_frame_size();
 
  if (v8_flags.maglev_assert_stack_size && v8_flags.debug_code) {
    MaglevAssembler::TemporaryRegisterScope temps(this);
    Register scratch = temps.AcquireScratch();
    int32_t expected_osr_stack_size =
        source_frame_size * kSystemPointerSize +
        StandardFrameConstants::kFixedFrameSizeFromFp;
    AddWord(scratch, sp, Operand(expected_osr_stack_size));
    MacroAssembler::SbxCheck(eq, AbortReason::kOsrUnexpectedStackSize, scratch,
                             Operand(fp));
  }
 
  uint32_t target_frame_size =
      graph->tagged_stack_slots() + graph->untagged_stack_slots();
  // CHECK_EQ(target_frame_size % 2, 1);
  CHECK_LE(source_frame_size, target_frame_size);
  if (source_frame_size < target_frame_size) {
    ASM_CODE_COMMENT_STRING(this, "Growing frame for OSR");
    uint32_t additional_tagged =
        source_frame_size < graph->tagged_stack_slots()
            ? graph->tagged_stack_slots() - source_frame_size
            : 0;
    for (size_t i = 0; i < additional_tagged; ++i) {
      Push(zero_reg);
    }
    uint32_t size_so_far = source_frame_size + additional_tagged;
    CHECK_LE(size_so_far, target_frame_size);
    if (size_so_far < target_frame_size) {
      Sub64(sp, sp,
            Operand((target_frame_size - size_so_far) * kSystemPointerSize));
    }
  }
}
 
void MaglevAssembler::Prologue(Graph* graph) {
  ASM_CODE_COMMENT(this);
  MaglevAssembler::TemporaryRegisterScope temps(this);
  //  We add two extra registers to the scope. Ideally we could add all the
  //  allocatable general registers, except Context, JSFunction, NewTarget and
  //  ArgCount. Unfortunately, OptimizeCodeOrTailCallOptimizedCodeSlot and
  //  LoadFeedbackVectorFlagsAndJumpIfNeedsProcessing pick random registers and
  //  we could alias those.
  // TODO(victorgomes): Fix these builtins to either use the scope or pass the
  // used registers manually.
  temps.Include({s7, s8});  // use register not overlapping with flags,
                            // feedback and so on
  DCHECK(!graph->is_osr());
 
  CallTarget();
  BailoutIfDeoptimized();
 
  if (graph->has_recursive_calls()) {
    BindCallTarget(code_gen_state()->entry_label());
  }
 
  // Tiering support.
#ifndef V8_ENABLE_LEAPTIERING
  if (v8_flags.turbofan) {
    using D = MaglevOptimizeCodeOrTailCallOptimizedCodeSlotDescriptor;
    Register flags = D::GetRegisterParameter(D::kFlags);
    Register feedback_vector = D::GetRegisterParameter(D::kFeedbackVector);
    DCHECK(!AreAliased(
        flags, feedback_vector,
        kJavaScriptCallArgCountRegister,  // flags - t4, feedback - a6,
                                          // kJavaScriptCallArgCountRegister -
                                          // a0
        kJSFunctionRegister, kContextRegister,
        kJavaScriptCallNewTargetRegister));
    DCHECK(!temps.Available().has(flags));
    DCHECK(!temps.Available().has(feedback_vector));
    Move(feedback_vector,
         compilation_info()->toplevel_compilation_unit()->feedback().object());
    Label needs_processing, done;
    LoadFeedbackVectorFlagsAndJumpIfNeedsProcessing(
        flags, feedback_vector, CodeKind::MAGLEV, &needs_processing);
    Jump(&done);
    bind(&needs_processing);
    TailCallBuiltin(Builtin::kMaglevOptimizeCodeOrTailCallOptimizedCodeSlot);
    bind(&done);
  }
#endif
 
  EnterFrame(StackFrame::MAGLEV);
  // Save arguments in frame.
  // TODO(leszeks): Consider eliding this frame if we don't make any calls
  // that could clobber these registers.
  // Push the context and the JSFunction.
  Push(kContextRegister);
  Push(kJSFunctionRegister);
  // Push the actual argument count and a _possible_ stack slot.
  Push(kJavaScriptCallArgCountRegister);
  // Initialize stack slots.
  if (graph->tagged_stack_slots() > 0) {
    ASM_CODE_COMMENT_STRING(this, "Initializing stack slots");
 
    // Magic value. Experimentally, an unroll size of 8 doesn't seem any
    // worse than fully unrolled pushes.
    const int kLoopUnrollSize = 8;
    int tagged_slots = graph->tagged_stack_slots();
 
    if (tagged_slots < 2 * kLoopUnrollSize) {
      // If the frame is small enough, just unroll the frame fill
      // completely.
      for (int i = 0; i < tagged_slots; ++i) {
        Push(zero_reg);
      }
    } else {
      // Extract the first few slots to round to the unroll size.
      int first_slots = tagged_slots % kLoopUnrollSize;
      for (int i = 0; i < first_slots; ++i) {
        Push(zero_reg);
      }
      MaglevAssembler::TemporaryRegisterScope temps(this);
      Register count = temps.AcquireScratch();
      Move(count, tagged_slots / kLoopUnrollSize);
      // We enter the loop unconditionally, so make sure we need to loop at
      // least once.
      DCHECK_GT(tagged_slots / kLoopUnrollSize, 0);
      Label loop;
      bind(&loop);
      for (int i = 0; i < kLoopUnrollSize; ++i) {
        Push(zero_reg);
      }
      Sub64(count, count, Operand(1));
      MacroAssembler::Branch(&loop, gt, count, Operand(zero_reg), Label::kNear);
    }
  }
  if (graph->untagged_stack_slots() > 0) {
    // Extend sp by the size of the remaining untagged part of the frame,
    // no need to initialise these.
    Sub64(sp, sp, Operand(graph->untagged_stack_slots() * kSystemPointerSize));
  }
}
 
void MaglevAssembler::MaybeEmitDeoptBuiltinsCall(size_t eager_deopt_count,
                                                 Label* eager_deopt_entry,
                                                 size_t lazy_deopt_count,
                                                 Label* lazy_deopt_entry) {
  ForceConstantPoolEmissionWithoutJump();
 
  DCHECK_GE(Deoptimizer::kLazyDeoptExitSize, Deoptimizer::kEagerDeoptExitSize);
 
  MaglevAssembler::TemporaryRegisterScope scope(this);
  Register scratch = scope.AcquireScratch();
  if (eager_deopt_count > 0) {
    bind(eager_deopt_entry);
    LoadEntryFromBuiltin(Builtin::kDeoptimizationEntry_Eager, scratch);
    MacroAssembler::Jump(scratch);
  }
  if (lazy_deopt_count > 0) {
    bind(lazy_deopt_entry);
    LoadEntryFromBuiltin(Builtin::kDeoptimizationEntry_Lazy, scratch);
    MacroAssembler::Jump(scratch);
  }
}
 
void MaglevAssembler::LoadSingleCharacterString(Register result,
                                                Register char_code,
                                                Register scratch) {
  DCHECK_NE(char_code, scratch);
  if (v8_flags.debug_code) {
    MacroAssembler::Assert(less_equal, AbortReason::kUnexpectedValue, char_code,
                           Operand(String::kMaxOneByteCharCode));
  }
  Register table = scratch;
  LoadRoot(table, RootIndex::kSingleCharacterStringTable);
  LoadTaggedFieldByIndex(result, table, char_code, kTaggedSize,
                         OFFSET_OF_DATA_START(FixedArray));
}
 
void MaglevAssembler::StringFromCharCode(RegisterSnapshot register_snapshot,
                                         Label* char_code_fits_one_byte,
                                         Register result, Register char_code,
                                         Register scratch,
                                         CharCodeMaskMode mask_mode) {
  ZeroExtendWord(char_code, char_code);
  AssertZeroExtended(char_code);
  DCHECK_NE(char_code, scratch);
  ZoneLabelRef done(this);
  if (mask_mode == CharCodeMaskMode::kMustApplyMask) {
    And(char_code, char_code, Operand(0xFFFF));
  }
  // Allocate two-bytes string if {char_code} doesn't fit one byte.
  MacroAssembler::Branch(  // FIXME: reimplement with JumpToDeferredIf
      MakeDeferredCode(
          [](MaglevAssembler* masm, RegisterSnapshot register_snapshot,
             ZoneLabelRef done, Register result, Register char_code,
             Register scratch) {
            MaglevAssembler::TemporaryRegisterScope temps(masm);
            // Ensure that {result} never aliases {scratch}, otherwise use
            // a temporary register to restore {result} at the end.
            const bool need_restore_result = (scratch == result);
            Register string =
                need_restore_result ? temps.AcquireScratch() : result;
            // Ensure that {char_code} never aliases {result}, otherwise use
            // the given {scratch} register.
            if (char_code == result) {
              __ Move(scratch, char_code);
              char_code = scratch;
            }
            DCHECK(char_code != string);
            DCHECK(scratch != string);
            DCHECK(!register_snapshot.live_tagged_registers.has(char_code));
            register_snapshot.live_registers.set(char_code);
            __ AllocateTwoByteString(register_snapshot, string, 1);
            __ And(scratch, char_code, Operand(0xFFFF));
            __ Sh(scratch, FieldMemOperand(
                               string, OFFSET_OF_DATA_START(SeqTwoByteString)));
            if (need_restore_result) {
              __ Move(result, string);
            }
            __ jmp(*done);
          },
          register_snapshot, done, result, char_code, scratch),
      Ugreater_equal, char_code, Operand(String::kMaxOneByteCharCode));
 
  if (char_code_fits_one_byte != nullptr) {
    bind(char_code_fits_one_byte);
  }
  LoadSingleCharacterString(result, char_code, scratch);
  bind(*done);
}
// Sets equality flag in pseudo flags reg.
void MaglevAssembler::IsObjectType(Register object, Register scratch1,
                                   Register scratch2, InstanceType type) {
  ASM_CODE_COMMENT(this);
  constexpr Register flags = MaglevAssembler::GetFlagsRegister();
  Label ConditionMet, Done;
  if (V8_STATIC_ROOTS_BOOL &&
      InstanceTypeChecker::UniqueMapOfInstanceType(type)) {
    LoadCompressedMap(scratch1, object);
    std::optional<RootIndex> expected =
        InstanceTypeChecker::UniqueMapOfInstanceType(type);
    Tagged_t expected_ptr = ReadOnlyRootPtr(*expected);
    li(scratch2, expected_ptr);
    Sll32(scratch2, scratch2, Operand(0));
    MacroAssembler::Branch(&ConditionMet, Condition::kEqual, scratch1,
                           Operand(scratch2), Label::kNear);
  } else {
    CompareObjectTypeAndJump(object, scratch1, scratch2, type,
                             Condition::kEqual, &ConditionMet, Label::kNear);
  }
  Li(flags, 1);  // Condition is not met by default and
                 // flags is set after a scratch is used,
                 // so no harm if they are aliased.
  Jump(&Done, Label::kNear);
  bind(&ConditionMet);
  Mv(flags, zero_reg);  // Condition is met
  bind(&Done);
}
 
void MaglevAssembler::StringCharCodeOrCodePointAt(
    BuiltinStringPrototypeCharCodeOrCodePointAt::Mode mode,
    RegisterSnapshot& register_snapshot, Register result, Register string,
    Register index, Register instance_type, [[maybe_unused]] Register scratch2,
    Label* result_fits_one_byte) {
  ZoneLabelRef done(this);
  Label seq_string;
  Label cons_string;
  Label sliced_string;
 
  Label* deferred_runtime_call = MakeDeferredCode(
      [](MaglevAssembler* masm,
         BuiltinStringPrototypeCharCodeOrCodePointAt::Mode mode,
         RegisterSnapshot register_snapshot, ZoneLabelRef done, Register result,
         Register string, Register index) {
        DCHECK(!register_snapshot.live_registers.has(result));
        DCHECK(!register_snapshot.live_registers.has(string));
        DCHECK(!register_snapshot.live_registers.has(index));
        {
          SaveRegisterStateForCall save_register_state(masm, register_snapshot);
          __ SmiTag(index);
          __ Push(string, index);
          __ Move(kContextRegister, masm->native_context().object());
          // This call does not throw nor can deopt.
          if (mode ==
              BuiltinStringPrototypeCharCodeOrCodePointAt::kCodePointAt) {
            __ CallRuntime(Runtime::kStringCodePointAt);
          } else {
            DCHECK_EQ(mode,
                      BuiltinStringPrototypeCharCodeOrCodePointAt::kCharCodeAt);
            __ CallRuntime(Runtime::kStringCharCodeAt);
          }
          save_register_state.DefineSafepoint();
          __ SmiUntag(kReturnRegister0);
          __ Move(result, kReturnRegister0);
        }
        __ jmp(*done);
      },
      mode, register_snapshot, done, result, string, index);
 
  // We might need to try more than one time for ConsString, SlicedString and
  // ThinString.
  Label loop;
  bind(&loop);
 
  if (v8_flags.debug_code) {
    Register scratch = instance_type;
 
    // Check if {string} is a string.
    AssertObjectTypeInRange(string, FIRST_STRING_TYPE, LAST_STRING_TYPE,
                            AbortReason::kUnexpectedValue);
 
    Lw(scratch, FieldMemOperand(string, offsetof(String, length_)));
    Check(kUnsignedLessThan, AbortReason::kUnexpectedValue, index,
          Operand(scratch));
  }
 
  // Get instance type.
  LoadInstanceType(instance_type, string);
 
  {
    MaglevAssembler::TemporaryRegisterScope temps(this);
    Register representation = temps.AcquireScratch();
 
    // TODO(victorgomes): Add fast path for external strings.
    And(representation, instance_type, Operand(kStringRepresentationMask));
    MacroAssembler::Branch(&seq_string, kEqual, representation,
                           Operand(kSeqStringTag), Label::kNear);
    MacroAssembler::Branch(&cons_string, kEqual, representation,
                           Operand(kConsStringTag), Label::kNear);
    MacroAssembler::Branch(&sliced_string, kEqual, representation,
                           Operand(kSlicedStringTag), Label::kNear);
    MacroAssembler::Branch(deferred_runtime_call, kNotEqual, representation,
                           Operand(kThinStringTag));
    // Fallthrough to thin string.
  }
 
  // Is a thin string.
  {
    LoadTaggedField(string, string, offsetof(ThinString, actual_));
    MacroAssembler::Branch(&loop, Label::kNear);
  }
 
  bind(&sliced_string);
  {
    MaglevAssembler::TemporaryRegisterScope temps(this);
    Register offset = temps.AcquireScratch();
 
    LoadAndUntagTaggedSignedField(offset, string,
                                  offsetof(SlicedString, offset_));
    LoadTaggedField(string, string, offsetof(SlicedString, parent_));
    Add32(index, index, Operand(offset));
    MacroAssembler::Branch(&loop, Label::kNear);
  }
 
  bind(&cons_string);
  {
    // Reuse {instance_type} register here, since CompareRoot requires a scratch
    // register as well.
    Register second_string = instance_type;
    LoadTaggedFieldWithoutDecompressing(second_string, string,
                                        offsetof(ConsString, second_));
    CompareRoot(second_string,
                RootIndex::kempty_string);  // Sets 1 to flag if not equal
    JumpIf(ne, deferred_runtime_call);      // Check the flag to not be equal 0
    LoadTaggedField(string, string, offsetof(ConsString, first_));
    MacroAssembler::Branch(&loop,
                           Label::kNear);  // Try again with first string.
  }
 
  bind(&seq_string);
  {
    Label two_byte_string;
    And(instance_type, instance_type, Operand(kStringEncodingMask));
    MacroAssembler::Branch(&two_byte_string, equal, instance_type,
                           Operand(kTwoByteStringTag), Label::kNear);
    // The result of one-byte string will be the same for both modes
    // (CharCodeAt/CodePointAt), since it cannot be the first half of a
    // surrogate pair.
    AddWord(result, string, Operand(index));
    Lbu(result, MemOperand(result, OFFSET_OF_DATA_START(SeqOneByteString) -
                                       kHeapObjectTag));
    MacroAssembler::Branch(result_fits_one_byte);
 
    bind(&two_byte_string);
    // {instance_type} is unused from this point, so we can use as scratch.
    Register scratch = instance_type;
 
    Register scaled_index = scratch;
    Sll32(scaled_index, index, Operand(1));
    AddWord(result, string, Operand(scaled_index));
    Lhu(result, MemOperand(result, OFFSET_OF_DATA_START(SeqTwoByteString) -
                                       kHeapObjectTag));
 
    if (mode == BuiltinStringPrototypeCharCodeOrCodePointAt::kCodePointAt) {
      Register first_code_point = scratch;
      And(first_code_point, result, Operand(0xfc00));
      MacroAssembler::Branch(*done, kNotEqual, first_code_point,
                             Operand(0xd800), Label::kNear);
 
      Register length = scratch;
      Lw(length, FieldMemOperand(string, offsetof(String, length_)));
      Add32(index, index, Operand(1));
      MacroAssembler::Branch(*done, kGreaterThanEqual, index, Operand(length),
                             Label::kNear);
 
      Register second_code_point = scratch;
      Sll32(second_code_point, index, Operand(1));
      AddWord(second_code_point, string, second_code_point);
      Lhu(second_code_point,
          MemOperand(second_code_point,
                     OFFSET_OF_DATA_START(SeqTwoByteString) - kHeapObjectTag));
 
      // {index} is not needed at this point.
      Register scratch2 = index;
      And(scratch2, second_code_point, Operand(0xfc00));
      MacroAssembler::Branch(*done, kNotEqual, scratch2, Operand(0xdc00),
                             Label::kNear);
 
      int surrogate_offset = 0x10000 - (0xd800 << 10) - 0xdc00;
      Add32(second_code_point, second_code_point, Operand(surrogate_offset));
      Sll32(result, result, Operand(10));
      Add32(result, result, Operand(second_code_point));
    }
 
    // Fallthrough.
  }
 
  bind(*done);
 
  if (v8_flags.debug_code) {
    // We make sure that the user of this macro is not relying in string and
    // index to not be clobbered.
    if (result != string) {
      Li(string, 0xdeadbeef);
    }
    if (result != index) {
      Li(index, 0xdeadbeef);
    }
  }
}
 
void MaglevAssembler::TruncateDoubleToInt32(Register dst, DoubleRegister src) {
  ZoneLabelRef done(this);
  Label* slow_path = MakeDeferredCode(
      [](MaglevAssembler* masm, DoubleRegister src, Register dst,
         ZoneLabelRef done) {
        __ push(ra);
        __ AllocateStackSpace(kDoubleSize);
        __ StoreDouble(src, MemOperand(sp, 0));
        __ CallBuiltin(Builtin::kDoubleToI);
        __ LoadWord(dst, MemOperand(sp, 0));
        __ AddWord(sp, sp, Operand(kDoubleSize));
        __ pop(ra);
        __ Jump(*done);
      },
      src, dst, done);
  TryInlineTruncateDoubleToI(dst, src, *done);
  Jump(slow_path);
  bind(*done);
  ZeroExtendWord(dst, dst);  // FIXME: is zero extension really needed here?
}
 
void MaglevAssembler::TryTruncateDoubleToInt32(Register dst, DoubleRegister src,
                                               Label* fail) {
  MaglevAssembler::TemporaryRegisterScope temps(this);
  DoubleRegister converted_back = temps.AcquireScratchDouble();
  Register rcmp = temps.AcquireScratch();
 
  // Convert the input float64 value to int32.
  Trunc_w_d(dst, src);
  // Convert that int32 value back to float64.
  Cvt_d_w(converted_back, dst);
  // Check that the result of the float64->int32->float64 is equal to the input
  // (i.e. that the conversion didn't truncate).
  CompareF64(rcmp, EQ, src, converted_back);  // rcmp is 0 if not equal
  MacroAssembler::Branch(
      fail, eq, rcmp, Operand(zero_reg));  // if we don't know branch distance
  // then lets use MacroAssembler::Branch, it will make sure we fit
 
  // Check if {input} is -0.
  Label check_done;
  BranchShort(&check_done, ne, dst, Operand(zero_reg));
 
  // In case of 0, we need to check for the IEEE 0 pattern (which is all zeros).
  MacroAssembler::Move(
      rcmp, src);  // FIXME: should we enable this in MaglevAssembler as well?
 
  MacroAssembler::Branch(fail, ne, rcmp, Operand(zero_reg));
 
  bind(&check_done);
}
 
void MaglevAssembler::TryTruncateDoubleToUint32(Register dst,
                                                DoubleRegister src,
                                                Label* fail) {
  MaglevAssembler::TemporaryRegisterScope temps(this);
  DoubleRegister converted_back = temps.AcquireScratchDouble();
  Register rcmp = temps.AcquireScratch();
 
  // Convert the input float64 value to uint32.
  Trunc_uw_d(dst, src);
  // Convert that uint32 value back to float64.
  Cvt_d_uw(converted_back, dst);
  // Check that the result of the float64->uint32->float64 is equal to the input
  // (i.e. that the conversion didn't truncate).
  CompareF64(rcmp, EQ, src, converted_back);  // rcmp is 0 if not equal
  MacroAssembler::Branch(fail, eq, rcmp, Operand(zero_reg));
 
  // Check if {input} is -0.
  Label check_done;
  BranchShort(&check_done, ne, dst, Operand(zero_reg));
 
  // In case of 0, we need to check for the IEEE 0 pattern (which is all zeros).
  MacroAssembler::Move(
      rcmp, src);  // FIXME: should we enable this in MaglevAssembler as well?
 
  MacroAssembler::Branch(fail, ne, rcmp, Operand(zero_reg));
 
  bind(&check_done);
}
 
void MaglevAssembler::TryChangeFloat64ToIndex(Register result,
                                              DoubleRegister value,
                                              Label* success, Label* fail) {
  MaglevAssembler::TemporaryRegisterScope temps(this);
  DoubleRegister converted_back = temps.AcquireScratchDouble();
  Register rcmp = temps.AcquireScratch();
 
  // Convert the input float64 value to int32.
  Trunc_w_d(result, value);
  // Convert that int32 value back to float64.
  Cvt_d_w(converted_back, result);
  // Check that the result of the float64->int32->float64 is equal to
  // the input (i.e. that the conversion didn't truncate).
  CompareF64(rcmp, EQ, value, converted_back);  // rcmp is 0 if not equal
  MacroAssembler::Branch(fail, eq, rcmp, Operand(zero_reg));
  Jump(success);
}
 
}  // namespace maglev
}  // namespace internal
}  // namespace v8