maglev-assembler.cc | 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.

#include "src/maglev/maglev-assembler.h"

#include "src/builtins/builtins-inl.h"
#include "src/codegen/reglist.h"
#include "src/maglev/maglev-assembler-inl.h"
#include "src/maglev/maglev-code-generator.h"
#include "src/numbers/conversions.h"

namespace v8 {
namespace internal {
namespace maglev {

#define __ …

void MaglevAssembler::AllocateHeapNumber(RegisterSnapshot register_snapshot,
                                         Register result,
                                         DoubleRegister value) { … }

void MaglevAssembler::AllocateTwoByteString(RegisterSnapshot register_snapshot,
                                            Register result, int length) { … }

Register MaglevAssembler::FromAnyToRegister(const Input& input,
                                            Register scratch) { … }

void MaglevAssembler::LoadSingleCharacterString(Register result,
                                                int char_code) { … }

void MaglevAssembler::LoadDataField(const PolymorphicAccessInfo& access_info,
                                    Register result, Register object,
                                    Register scratch) { … }

void MaglevAssembler::JumpIfNotUndetectable(Register object, Register scratch,
                                            CheckType check_type, Label* target,
                                            Label::Distance distance) { … }

void MaglevAssembler::JumpIfUndetectable(Register object, Register scratch,
                                         CheckType check_type, Label* target,
                                         Label::Distance distance) { … }

void MaglevAssembler::JumpIfNotCallable(Register object, Register scratch,
                                        CheckType check_type, Label* target,
                                        Label::Distance distance) { … }

void MaglevAssembler::EnsureWritableFastElements(
    RegisterSnapshot register_snapshot, Register elements, Register object,
    Register scratch) { … }

void MaglevAssembler::ToBoolean(Register value, CheckType check_type,
                                ZoneLabelRef is_true, ZoneLabelRef is_false,
                                bool fallthrough_when_true) { … }

void MaglevAssembler::MaterialiseValueNode(Register dst, ValueNode* value) { … }

void MaglevAssembler::TestTypeOf(
    Register object, interpreter::TestTypeOfFlags::LiteralFlag literal,
    Label* is_true, Label::Distance true_distance, bool fallthrough_when_true,
    Label* is_false, Label::Distance false_distance,
    bool fallthrough_when_false) { … }

template <MaglevAssembler::StoreMode store_mode>
void MaglevAssembler::CheckAndEmitDeferredWriteBarrier(
    Register object, OffsetTypeFor<store_mode> offset, Register value,
    RegisterSnapshot register_snapshot, ValueIsCompressed value_is_compressed,
    ValueCanBeSmi value_can_be_smi) { … }

#ifdef V8_ENABLE_SANDBOX

void MaglevAssembler::CheckAndEmitDeferredIndirectPointerWriteBarrier(
    Register object, int offset, Register value,
    RegisterSnapshot register_snapshot, IndirectPointerTag tag) { … }

#endif  // V8_ENABLE_SANDBOX

void MaglevAssembler::StoreTaggedFieldWithWriteBarrier(
    Register object, int offset, Register value,
    RegisterSnapshot register_snapshot, ValueIsCompressed value_is_compressed,
    ValueCanBeSmi value_can_be_smi) { … }

#ifdef V8_ENABLE_SANDBOX

void MaglevAssembler::StoreTrustedPointerFieldWithWriteBarrier(
    Register object, int offset, Register value,
    RegisterSnapshot register_snapshot, IndirectPointerTag tag) { … }

#endif  // V8_ENABLE_SANDBOX

void MaglevAssembler::StoreFixedArrayElementWithWriteBarrier(
    Register array, Register index, Register value,
    RegisterSnapshot register_snapshot) { … }

void MaglevAssembler::GenerateCheckConstTrackingLetCellFooter(Register context,
                                                              Register data,
                                                              int index,
                                                              Label* done) { … }

void MaglevAssembler::TryMigrateInstance(Register object,
                                         RegisterSnapshot& register_snapshot,
                                         Label* fail) { … }

}  // namespace maglev
}  // namespace internal
}  // namespace v8
chromium/v8/src/maglev/maglev-assembler.cc
