// Copyright 2016 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_CODEGEN_CODE_STUB_ASSEMBLER_H_

#define V8_CODEGEN_CODE_STUB_ASSEMBLER_H_

#include <functional>

#include <optional>

#include "src/base/functional/function-ref.h"

#include "src/base/macros.h"

#include "src/codegen/bailout-reason.h"

#include "src/codegen/heap-object-list.h"

#include "src/codegen/tnode.h"

#include "src/common/globals.h"

#include "src/common/message-template.h"

#include "src/compiler/code-assembler.h"

#include "src/numbers/integer-literal.h"

#include "src/objects/api-callbacks.h"

#include "src/objects/arguments.h"

#include "src/objects/bigint.h"

#include "src/objects/cell.h"

#include "src/objects/dictionary.h"

#include "src/objects/feedback-vector.h"

#include "src/objects/fixed-array.h"

#include "src/objects/foreign.h"

#include "src/objects/heap-number.h"

#include "src/objects/heap-object.h"

#include "src/objects/hole.h"

#include "src/objects/js-function.h"

#include "src/objects/js-objects.h"

#include "src/objects/js-promise.h"

#include "src/objects/js-proxy.h"

#include "src/objects/number-string-cache.h"

#include "src/objects/objects.h"

#include "src/objects/oddball.h"

#include "src/objects/shared-function-info.h"

#include "src/objects/smi.h"

#include "src/objects/string.h"

#include "src/objects/swiss-name-dictionary.h"

#include "src/objects/tagged-index.h"

#include "src/objects/tagged.h"

#include "src/objects/templates.h"

#include "src/roots/roots.h"

#include "torque-generated/exported-macros-assembler.h"

#if V8_ENABLE_WEBASSEMBLY

#include "src/wasm/wasm-objects.h"

#endif // V8_ENABLE_WEBASSEMBLY

namespace v8 {

namespace internal {

#include "src/codegen/define-code-stub-assembler-macros.inc"

class CallInterfaceDescriptor;

class CodeStubArguments;

class CodeStubAssembler;

class StatsCounter;

class StubCache;

enum class PrimitiveType { kBoolean, kNumber, kString, kSymbol };

// Provides JavaScript-specific "macro-assembler" functionality on top of the

// CodeAssembler. By factoring the JavaScript-isms out of the CodeAssembler,

// it's possible to add JavaScript-specific useful CodeAssembler "macros"

// without modifying files in the compiler directory (and requiring a review

// from a compiler directory OWNER).

class V8_EXPORT_PRIVATE CodeStubAssembler

: public compiler::CodeAssembler,

public TorqueGeneratedExportedMacrosAssembler {

public:

using ScopedExceptionHandler = compiler::ScopedExceptionHandler;

template <typename T>

using LazyNode = std::function<TNode<T>()>;

explicit CodeStubAssembler(compiler::CodeAssemblerState* state);

enum class AllocationFlag : uint8_t {

kNone = 0,

kDoubleAlignment = 1,

kPretenured = 1 << 1

};

enum SlackTrackingMode {

kWithSlackTracking,

kNoSlackTracking,

kDontInitializeInObjectProperties,

};

using AllocationFlags = base::Flags<AllocationFlag>;

TNode<UintPtrT> ArrayBufferMaxByteLength();

TNode<IntPtrT> ParameterToIntPtr(TNode<Smi> value) { return SmiUntag(value); }

TNode<IntPtrT> ParameterToIntPtr(TNode<IntPtrT> value) { return value; }

TNode<IntPtrT> ParameterToIntPtr(TNode<UintPtrT> value) {

return Signed(value);

}

TNode<IntPtrT> ParameterToIntPtr(TNode<TaggedIndex> value) {

return TaggedIndexToIntPtr(value);

}

TNode<Smi> ParameterToTagged(TNode<Smi> value) { return value; }

TNode<Smi> ParameterToTagged(TNode<IntPtrT> value) { return SmiTag(value); }

template <typename TIndex>

TNode<TIndex> TaggedToParameter(TNode<Smi> value);

bool ToParameterConstant(TNode<Smi> node, intptr_t* out) {

if (TryToIntPtrConstant(node, out)) {

return true;

}

return false;

}

bool ToParameterConstant(TNode<IntPtrT> node, intptr_t* out) {

intptr_t constant;

if (TryToIntPtrConstant(node, &constant)) {

*out = constant;

return true;

}

return false;

}

#if defined(BINT_IS_SMI)

TNode<Smi> BIntToSmi(TNode<BInt> source) { return source; }

TNode<IntPtrT> BIntToIntPtr(TNode<BInt> source) {

return SmiToIntPtr(source);

}

TNode<BInt> SmiToBInt(TNode<Smi> source) { return source; }

TNode<BInt> IntPtrToBInt(TNode<IntPtrT> source) {

return SmiFromIntPtr(source);

}

#elif defined(BINT_IS_INTPTR)

TNode<Smi> BIntToSmi(TNode<BInt> source) { return SmiFromIntPtr(source); }

TNode<IntPtrT> BIntToIntPtr(TNode<BInt> source) { return source; }

TNode<BInt> SmiToBInt(TNode<Smi> source) { return SmiToIntPtr(source); }

TNode<BInt> IntPtrToBInt(TNode<IntPtrT> source) { return source; }

#else

#error Unknown architecture.

#endif

// Convert<T> is intended to handle all converting type changes, i.e. when

// the underlying representation may change (extend, truncate, ...) in

// some way.

//

// See also convert.tq.

//

// Please add new overloads as convenient.

template <class To, class From>

TNode<To> Convert(TNode<From> from);

TNode<IntPtrT> TaggedIndexToIntPtr(TNode<TaggedIndex> value);

TNode<TaggedIndex> IntPtrToTaggedIndex(TNode<IntPtrT> value);

// TODO(v8:10047): Get rid of these conversions eventually.

TNode<Smi> TaggedIndexToSmi(TNode<TaggedIndex> value);

TNode<TaggedIndex> SmiToTaggedIndex(TNode<Smi> value);

// Pointer compression specific. Ensures that the upper 32 bits of a Smi

// contain the sign of a lower 32 bits so that the Smi can be directly used

// as an index in element offset computation.

TNode<Smi> NormalizeSmiIndex(TNode<Smi> smi_index);

TNode<Smi> TaggedToSmi(TNode<Object> value, Label* fail) {

GotoIf(TaggedIsNotSmi(value), fail);

return UncheckedCast<Smi>(value);

}

TNode<Smi> TaggedToPositiveSmi(TNode<Object> value, Label* fail) {

GotoIfNot(TaggedIsPositiveSmi(value), fail);

return UncheckedCast<Smi>(value);

}

TNode<String> TaggedToDirectString(TNode<Object> value, Label* fail);

TNode<HeapObject> TaggedToHeapObject(TNode<Object> value, Label* fail) {

GotoIf(TaggedIsSmi(value), fail);

return UncheckedCast<HeapObject>(value);

}

TNode<Uint16T> Uint16Constant(uint16_t t) {

return UncheckedCast<Uint16T>(Int32Constant(t));

}

TNode<JSDataView> HeapObjectToJSDataView(TNode<HeapObject> heap_object,

Label* fail) {

GotoIfNot(IsJSDataView(heap_object), fail);

return CAST(heap_object);

}

TNode<JSProxy> HeapObjectToJSProxy(TNode<HeapObject> heap_object,

Label* fail) {

GotoIfNot(IsJSProxy(heap_object), fail);

return CAST(heap_object);

}

TNode<JSStringIterator> HeapObjectToJSStringIterator(

TNode<HeapObject> heap_object, Label* fail) {

GotoIfNot(IsJSStringIterator(heap_object), fail);

return CAST(heap_object);

}

TNode<JSCallable> HeapObjectToCallable(TNode<HeapObject> heap_object,

Label* fail) {

GotoIfNot(IsCallable(heap_object), fail);

return CAST(heap_object);

}

TNode<String> HeapObjectToString(TNode<HeapObject> heap_object, Label* fail) {

GotoIfNot(IsString(heap_object), fail);

return CAST(heap_object);

}

TNode<JSReceiver> HeapObjectToConstructor(TNode<HeapObject> heap_object,

Label* fail) {

GotoIfNot(IsConstructor(heap_object), fail);

return CAST(heap_object);

}

TNode<JSFunction> HeapObjectToJSFunctionWithPrototypeSlot(

TNode<HeapObject> heap_object, Label* fail) {

GotoIfNot(IsJSFunctionWithPrototypeSlot(heap_object), fail);

return CAST(heap_object);

}

template <typename T>

TNode<T> RunLazy(LazyNode<T> lazy) {

return lazy();

}

#define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName) \

TNode<Smi> OpName(TNode<Smi> a, TNode<Smi> b) { return SmiOpName(a, b); } \

TNode<IntPtrT> OpName(TNode<IntPtrT> a, TNode<IntPtrT> b) { \

return IntPtrOpName(a, b); \

} \

TNode<UintPtrT> OpName(TNode<UintPtrT> a, TNode<UintPtrT> b) { \

return Unsigned(IntPtrOpName(Signed(a), Signed(b))); \

} \

TNode<RawPtrT> OpName(TNode<RawPtrT> a, TNode<RawPtrT> b) { \

return ReinterpretCast<RawPtrT>(IntPtrOpName( \

ReinterpretCast<IntPtrT>(a), ReinterpretCast<IntPtrT>(b))); \

}

// TODO(v8:9708): Define BInt operations once all uses are ported.

PARAMETER_BINOP(IntPtrOrSmiAdd, IntPtrAdd, SmiAdd)

PARAMETER_BINOP(IntPtrOrSmiSub, IntPtrSub, SmiSub)

#undef PARAMETER_BINOP

#define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName) \

TNode<BoolT> OpName(TNode<Smi> a, TNode<Smi> b) { return SmiOpName(a, b); } \

TNode<BoolT> OpName(TNode<IntPtrT> a, TNode<IntPtrT> b) { \

return IntPtrOpName(a, b); \

} \

/* IntPtrXXX comparisons shouldn't be used with unsigned types, use */ \

/* UintPtrXXX operations explicitly instead. */ \

TNode<BoolT> OpName(TNode<UintPtrT> a, TNode<UintPtrT> b) { UNREACHABLE(); } \

TNode<BoolT> OpName(TNode<RawPtrT> a, TNode<RawPtrT> b) { UNREACHABLE(); }

// TODO(v8:9708): Define BInt operations once all uses are ported.

PARAMETER_BINOP(IntPtrOrSmiEqual, WordEqual, SmiEqual)

PARAMETER_BINOP(IntPtrOrSmiNotEqual, WordNotEqual, SmiNotEqual)

PARAMETER_BINOP(IntPtrOrSmiLessThan, IntPtrLessThan, SmiLessThan)

PARAMETER_BINOP(IntPtrOrSmiLessThanOrEqual, IntPtrLessThanOrEqual,

SmiLessThanOrEqual)

PARAMETER_BINOP(IntPtrOrSmiGreaterThan, IntPtrGreaterThan, SmiGreaterThan)

#undef PARAMETER_BINOP

#define PARAMETER_BINOP(OpName, UintPtrOpName, SmiOpName) \

TNode<BoolT> OpName(TNode<Smi> a, TNode<Smi> b) { return SmiOpName(a, b); } \

TNode<BoolT> OpName(TNode<IntPtrT> a, TNode<IntPtrT> b) { \

return UintPtrOpName(Unsigned(a), Unsigned(b)); \

} \

TNode<BoolT> OpName(TNode<UintPtrT> a, TNode<UintPtrT> b) { \

return UintPtrOpName(a, b); \

} \

TNode<BoolT> OpName(TNode<RawPtrT> a, TNode<RawPtrT> b) { \

return UintPtrOpName(a, b); \

}

// TODO(v8:9708): Define BInt operations once all uses are ported.

PARAMETER_BINOP(UintPtrOrSmiEqual, WordEqual, SmiEqual)

PARAMETER_BINOP(UintPtrOrSmiNotEqual, WordNotEqual, SmiNotEqual)

PARAMETER_BINOP(UintPtrOrSmiLessThan, UintPtrLessThan, SmiBelow)

PARAMETER_BINOP(UintPtrOrSmiLessThanOrEqual, UintPtrLessThanOrEqual,

SmiBelowOrEqual)

PARAMETER_BINOP(UintPtrOrSmiGreaterThan, UintPtrGreaterThan, SmiAbove)

PARAMETER_BINOP(UintPtrOrSmiGreaterThanOrEqual, UintPtrGreaterThanOrEqual,

SmiAboveOrEqual)

#undef PARAMETER_BINOP

uintptr_t ConstexprUintPtrShl(uintptr_t a, int32_t b) { return a << b; }

uintptr_t ConstexprUintPtrShr(uintptr_t a, int32_t b) { return a >> b; }

intptr_t ConstexprIntPtrAdd(intptr_t a, intptr_t b) { return a + b; }

uintptr_t ConstexprUintPtrAdd(uintptr_t a, uintptr_t b) { return a + b; }

intptr_t ConstexprWordNot(intptr_t a) { return ~a; }

uintptr_t ConstexprWordNot(uintptr_t a) { return ~a; }

#if defined(V8_EXTERNAL_CODE_SPACE) || defined(V8_ENABLE_SANDBOX)

void CheckObjectComparisonAllowed(TNode<AnyTaggedT> a, TNode<AnyTaggedT> b,

SourceLocation loc);

#endif

TNode<BoolT> TaggedEqual(TNode<AnyTaggedT> a, TNode<AnyTaggedT> b,

SourceLocation loc = SourceLocation::Current()) {

#if defined(V8_EXTERNAL_CODE_SPACE) || defined(V8_ENABLE_SANDBOX)

if (v8_flags.enable_slow_asserts) {

CheckObjectComparisonAllowed(a, b, loc);

}

#endif

if (COMPRESS_POINTERS_BOOL) {

return Word32Equal(ReinterpretCast<Word32T>(a),

ReinterpretCast<Word32T>(b));

} else {

return WordEqual(ReinterpretCast<WordT>(a), ReinterpretCast<WordT>(b));

}

}

TNode<BoolT> TaggedNotEqual(TNode<AnyTaggedT> a, TNode<AnyTaggedT> b,

SourceLocation loc = SourceLocation::Current()) {

return Word32BinaryNot(TaggedEqual(a, b, loc));

}

// A variant of TaggedEqual which allows comparing objects in different

// pointer compression cages. In particular, this should be used when

// comparing objects in trusted- or code space with objects in the main

// pointer compression cage. Currently only defined for HeapObject, this

// type can be expanded if needed.

TNode<BoolT> SafeEqual(TNode<HeapObject> a, TNode<HeapObject> b) {

if (V8_EXTERNAL_CODE_SPACE_BOOL || V8_ENABLE_SANDBOX_BOOL) {

return WordEqual(BitcastTaggedToWord(a), BitcastTaggedToWord(b));

}

return TaggedEqual(a, b);

}

TNode<BoolT> SafeNotEqual(TNode<HeapObject> a, TNode<HeapObject> b) {

return Word32BinaryNot(SafeEqual(a, b));

}

TNode<Smi> NoContextConstant();

TNode<IntPtrT> StackAlignmentInBytes() {

// This node makes the graph platform-specific. To make sure that the graph

// structure is still platform independent, UniqueIntPtrConstants are used

// here.

#if V8_TARGET_ARCH_ARM64

return UniqueIntPtrConstant(16);

#else

return UniqueIntPtrConstant(kSystemPointerSize);

#endif

}

#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name) \

TNode<RemoveTagged< \

decltype(std::declval<ReadOnlyRoots>().rootAccessorName())>::type> \

name##Constant();

HEAP_IMMUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR)

#undef HEAP_CONSTANT_ACCESSOR

#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name) \

TNode<RemoveTagged<decltype(std::declval<Heap>().rootAccessorName())>::type> \

name##Constant();

HEAP_MUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR)

#undef HEAP_CONSTANT_ACCESSOR

#define HEAP_CONSTANT_TEST(rootIndexName, rootAccessorName, name) \

TNode<BoolT> Is##name(TNode<Object> value, \

SourceLocation loc = SourceLocation::Current()); \

TNode<BoolT> IsNot##name(TNode<Object> value, \

SourceLocation loc = SourceLocation::Current());

HEAP_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_TEST)

#undef HEAP_CONSTANT_TEST

TNode<BInt> BIntConstant(int value);

template <typename TIndex>

TNode<TIndex> IntPtrOrSmiConstant(int value);

bool TryGetIntPtrOrSmiConstantValue(TNode<Smi> maybe_constant, int* value);

bool TryGetIntPtrOrSmiConstantValue(TNode<IntPtrT> maybe_constant,

int* value);

TNode<IntPtrT> PopulationCountFallback(TNode<UintPtrT> value);

TNode<Int64T> PopulationCount64(TNode<Word64T> value);

TNode<Int32T> PopulationCount32(TNode<Word32T> value);

TNode<Int64T> CountTrailingZeros64(TNode<Word64T> value);

TNode<Int32T> CountTrailingZeros32(TNode<Word32T> value);

TNode<Int64T> CountLeadingZeros64(TNode<Word64T> value);

TNode<Int32T> CountLeadingZeros32(TNode<Word32T> value);

TNode<Int32T> NumberToMathClz32(TNode<Number> value);

// Round the 32bits payload of the provided word up to the next power of two.

TNode<IntPtrT> IntPtrRoundUpToPowerOfTwo32(TNode<IntPtrT> value);

// Select the maximum of the two provided IntPtr values.

TNode<IntPtrT> IntPtrMax(TNode<IntPtrT> left, TNode<IntPtrT> right);

// Select the minimum of the two provided IntPtr values.

TNode<IntPtrT> IntPtrMin(TNode<IntPtrT> left, TNode<IntPtrT> right);

TNode<UintPtrT> UintPtrMin(TNode<UintPtrT> left, TNode<UintPtrT> right);

// Float64 operations.

TNode<BoolT> Float64AlmostEqual(TNode<Float64T> x, TNode<Float64T> y,

double max_relative_error = 0.0000001);

TNode<Float64T> Float64Ceil(TNode<Float64T> x);

TNode<Float64T> Float64Floor(TNode<Float64T> x);

TNode<Float64T> Float64Round(TNode<Float64T> x);

TNode<Float64T> Float64RoundToEven(TNode<Float64T> x);

TNode<Float64T> Float64Trunc(TNode<Float64T> x);

// Select the minimum of the two provided Number values.

TNode<Number> NumberMax(TNode<Number> left, TNode<Number> right);

// Select the minimum of the two provided Number values.

TNode<Number> NumberMin(TNode<Number> left, TNode<Number> right);

// Returns true iff the given value fits into smi range and is >= 0.

TNode<BoolT> IsValidPositiveSmi(TNode<IntPtrT> value);

// Tag an IntPtr as a Smi value.

TNode<Smi> SmiTag(TNode<IntPtrT> value);

// Untag a Smi value as an IntPtr.

TNode<IntPtrT> SmiUntag(TNode<Smi> value);

// Untag a positive Smi value as an IntPtr, it's slightly better than

// SmiUntag() because it doesn't have to do sign extension.

TNode<IntPtrT> PositiveSmiUntag(TNode<Smi> value);

// Smi conversions.

TNode<Float64T> SmiToFloat64(TNode<Smi> value);

TNode<Smi> SmiFromIntPtr(TNode<IntPtrT> value) { return SmiTag(value); }

TNode<Smi> SmiFromInt32(TNode<Int32T> value);

TNode<Smi> SmiFromUint32(TNode<Uint32T> value);

TNode<IntPtrT> SmiToIntPtr(TNode<Smi> value) { return SmiUntag(value); }

TNode<Int32T> SmiToInt32(TNode<Smi> value);

TNode<Uint32T> PositiveSmiToUint32(TNode<Smi> value);

// Smi operations.

#define SMI_ARITHMETIC_BINOP(SmiOpName, IntPtrOpName, Int32OpName) \

TNode<Smi> SmiOpName(TNode<Smi> a, TNode<Smi> b) { \

if (SmiValuesAre32Bits()) { \

return BitcastWordToTaggedSigned( \

IntPtrOpName(BitcastTaggedToWordForTagAndSmiBits(a), \

BitcastTaggedToWordForTagAndSmiBits(b))); \

} else { \

DCHECK(SmiValuesAre31Bits()); \

return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(Int32OpName( \

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(a)), \

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(b))))); \

} \

}

SMI_ARITHMETIC_BINOP(SmiAdd, IntPtrAdd, Int32Add)

SMI_ARITHMETIC_BINOP(SmiSub, IntPtrSub, Int32Sub)

SMI_ARITHMETIC_BINOP(SmiAnd, WordAnd, Word32And)

SMI_ARITHMETIC_BINOP(SmiOr, WordOr, Word32Or)

SMI_ARITHMETIC_BINOP(SmiXor, WordXor, Word32Xor)

#undef SMI_ARITHMETIC_BINOP

TNode<IntPtrT> TryIntPtrAdd(TNode<IntPtrT> a, TNode<IntPtrT> b,

Label* if_overflow);

TNode<IntPtrT> TryIntPtrSub(TNode<IntPtrT> a, TNode<IntPtrT> b,

Label* if_overflow);

TNode<IntPtrT> TryIntPtrMul(TNode<IntPtrT> a, TNode<IntPtrT> b,

Label* if_overflow);

TNode<IntPtrT> TryIntPtrDiv(TNode<IntPtrT> a, TNode<IntPtrT> b,

Label* if_div_zero);

TNode<IntPtrT> TryIntPtrMod(TNode<IntPtrT> a, TNode<IntPtrT> b,

Label* if_div_zero);

TNode<Int32T> TryInt32Mul(TNode<Int32T> a, TNode<Int32T> b,

Label* if_overflow);

TNode<Smi> TrySmiAdd(TNode<Smi> a, TNode<Smi> b, Label* if_overflow);

TNode<Smi> TrySmiSub(TNode<Smi> a, TNode<Smi> b, Label* if_overflow);

TNode<Smi> TrySmiAbs(TNode<Smi> a, Label* if_overflow);

TNode<Smi> UnsignedSmiShl(TNode<Smi> a, int shift) {

if (SmiValuesAre32Bits()) {

return BitcastWordToTaggedSigned(

WordShl(BitcastTaggedToWordForTagAndSmiBits(a), shift));

} else {

DCHECK(SmiValuesAre31Bits());

return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(Word32Shl(

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(a)),

Int32Constant(shift))));

}

}

TNode<Smi> SmiShl(TNode<Smi> a, int shift) {

TNode<Smi> result = UnsignedSmiShl(a, shift);

// Smi shift have different result to int32 shift when the inputs are not

// strictly limited. The CSA_DCHECK is to ensure valid inputs.

CSA_DCHECK(

this, TaggedEqual(result, BitwiseOp(SmiToInt32(a), Int32Constant(shift),

Operation::kShiftLeft)));

return result;

}

TNode<Smi> SmiShr(TNode<Smi> a, int shift) {

TNode<Smi> result;

if (kTaggedSize == kInt64Size) {

result = BitcastWordToTaggedSigned(

WordAnd(WordShr(BitcastTaggedToWordForTagAndSmiBits(a), shift),

BitcastTaggedToWordForTagAndSmiBits(SmiConstant(-1))));

} else {

// For pointer compressed Smis, we want to make sure that we truncate to

// int32 before shifting, to avoid the values of the top 32-bits from

// leaking into the sign bit of the smi.

result = BitcastWordToTaggedSigned(WordAnd(

ChangeInt32ToIntPtr(Word32Shr(

TruncateWordToInt32(BitcastTaggedToWordForTagAndSmiBits(a)),

shift)),

BitcastTaggedToWordForTagAndSmiBits(SmiConstant(-1))));

}

// Smi shift have different result to int32 shift when the inputs are not

// strictly limited. The CSA_DCHECK is to ensure valid inputs.

CSA_DCHECK(

this, TaggedEqual(result, BitwiseOp(SmiToInt32(a), Int32Constant(shift),

Operation::kShiftRightLogical)));

return result;

}

TNode<Smi> SmiSar(TNode<Smi> a, int shift) {

// The number of shift bits is |shift % 64| for 64-bits value and |shift %

// 32| for 32-bits value. The DCHECK is to ensure valid inputs.

DCHECK_LT(shift, 32);

if (kTaggedSize == kInt64Size) {

return BitcastWordToTaggedSigned(

WordAnd(WordSar(BitcastTaggedToWordForTagAndSmiBits(a), shift),

BitcastTaggedToWordForTagAndSmiBits(SmiConstant(-1))));

} else {

// For pointer compressed Smis, we want to make sure that we truncate to

// int32 before shifting, to avoid the values of the top 32-bits from

// changing the sign bit of the smi.

return BitcastWordToTaggedSigned(WordAnd(

ChangeInt32ToIntPtr(Word32Sar(

TruncateWordToInt32(BitcastTaggedToWordForTagAndSmiBits(a)),

shift)),

BitcastTaggedToWordForTagAndSmiBits(SmiConstant(-1))));

}

}

TNode<Smi> WordOrSmiShr(TNode<Smi> a, int shift) { return SmiShr(a, shift); }

TNode<IntPtrT> WordOrSmiShr(TNode<IntPtrT> a, int shift) {

return WordShr(a, shift);

}

#define SMI_COMPARISON_OP(SmiOpName, IntPtrOpName, Int32OpName) \

TNode<BoolT> SmiOpName(TNode<Smi> a, TNode<Smi> b) { \

if (kTaggedSize == kInt64Size) { \

return IntPtrOpName(BitcastTaggedToWordForTagAndSmiBits(a), \

BitcastTaggedToWordForTagAndSmiBits(b)); \

} else { \

DCHECK_EQ(kTaggedSize, kInt32Size); \

DCHECK(SmiValuesAre31Bits()); \

return Int32OpName( \

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(a)), \

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(b))); \

} \

}

SMI_COMPARISON_OP(SmiEqual, WordEqual, Word32Equal)

SMI_COMPARISON_OP(SmiNotEqual, WordNotEqual, Word32NotEqual)

SMI_COMPARISON_OP(SmiAbove, UintPtrGreaterThan, Uint32GreaterThan)

SMI_COMPARISON_OP(SmiAboveOrEqual, UintPtrGreaterThanOrEqual,

Uint32GreaterThanOrEqual)

SMI_COMPARISON_OP(SmiBelow, UintPtrLessThan, Uint32LessThan)

SMI_COMPARISON_OP(SmiBelowOrEqual, UintPtrLessThanOrEqual,

Uint32LessThanOrEqual)

SMI_COMPARISON_OP(SmiLessThan, IntPtrLessThan, Int32LessThan)

SMI_COMPARISON_OP(SmiLessThanOrEqual, IntPtrLessThanOrEqual,

Int32LessThanOrEqual)

SMI_COMPARISON_OP(SmiGreaterThan, IntPtrGreaterThan, Int32GreaterThan)

SMI_COMPARISON_OP(SmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual,

Int32GreaterThanOrEqual)

#undef SMI_COMPARISON_OP

TNode<Smi> SmiMax(TNode<Smi> a, TNode<Smi> b);

TNode<Smi> SmiMin(TNode<Smi> a, TNode<Smi> b);

// Computes a % b for Smi inputs a and b; result is not necessarily a Smi.

TNode<Number> SmiMod(TNode<Smi> a, TNode<Smi> b);

// Computes a * b for Smi inputs a and b; result is not necessarily a Smi.

TNode<Number> SmiMul(TNode<Smi> a, TNode<Smi> b);

// Tries to compute dividend / divisor for Smi inputs; branching to bailout

// if the division needs to be performed as a floating point operation.

TNode<Smi> TrySmiDiv(TNode<Smi> dividend, TNode<Smi> divisor, Label* bailout);

// Compares two Smis a and b as if they were converted to strings and then

// compared lexicographically. Returns:

// -1 iff x < y.

// 0 iff x == y.

// 1 iff x > y.

TNode<Smi> SmiLexicographicCompare(TNode<Smi> x, TNode<Smi> y);

// Returns Smi::zero() if no CoverageInfo exists.

TNode<Object> GetCoverageInfo(TNode<SharedFunctionInfo> sfi);

#ifdef BINT_IS_SMI

#define BINT_COMPARISON_OP(BIntOpName, SmiOpName, IntPtrOpName) \

TNode<BoolT> BIntOpName(TNode<BInt> a, TNode<BInt> b) { \

return SmiOpName(a, b); \

}

#else

#define BINT_COMPARISON_OP(BIntOpName, SmiOpName, IntPtrOpName) \

TNode<BoolT> BIntOpName(TNode<BInt> a, TNode<BInt> b) { \

return IntPtrOpName(a, b); \

}

#endif

BINT_COMPARISON_OP(BIntEqual, SmiEqual, WordEqual)

BINT_COMPARISON_OP(BIntNotEqual, SmiNotEqual, WordNotEqual)

BINT_COMPARISON_OP(BIntAbove, SmiAbove, UintPtrGreaterThan)

BINT_COMPARISON_OP(BIntAboveOrEqual, SmiAboveOrEqual,

UintPtrGreaterThanOrEqual)

BINT_COMPARISON_OP(BIntBelow, SmiBelow, UintPtrLessThan)

BINT_COMPARISON_OP(BIntLessThan, SmiLessThan, IntPtrLessThan)

BINT_COMPARISON_OP(BIntLessThanOrEqual, SmiLessThanOrEqual,

IntPtrLessThanOrEqual)

BINT_COMPARISON_OP(BIntGreaterThan, SmiGreaterThan, IntPtrGreaterThan)

BINT_COMPARISON_OP(BIntGreaterThanOrEqual, SmiGreaterThanOrEqual,

IntPtrGreaterThanOrEqual)

#undef BINT_COMPARISON_OP

// Smi | HeapNumber operations.

TNode<Number> NumberInc(TNode<Number> value);

TNode<Number> NumberDec(TNode<Number> value);

TNode<Number> NumberAdd(TNode<Number> a, TNode<Number> b);

TNode<Number> NumberSub(TNode<Number> a, TNode<Number> b);

void GotoIfNotNumber(TNode<Object> value, Label* is_not_number);

#ifdef V8_ENABLE_UNDEFINED_DOUBLE

void GotoIfNumberOrUndefined(TNode<Object> value,

Label* is_number_or_undefined);

void GotoIfNotNumberOrUndefined(TNode<Object> value,

Label* is_not_number_or_undefined);

#endif // V8_ENABLE_UNDEFINED_DOUBLE

void GotoIfNumber(TNode<Object> value, Label* is_number);

TNode<Number> SmiToNumber(TNode<Smi> v) { return v; }

// BigInt operations.

void GotoIfLargeBigInt(TNode<BigInt> bigint, Label* true_label);

void GotoIfLazyClosure(TNode<JSAnyOrSharedFunctionInfo> value,

Label* if_true);

TNode<Word32T> NormalizeShift32OperandIfNecessary(TNode<Word32T> right32);

TNode<Number> BitwiseOp(TNode<Word32T> left32, TNode<Word32T> right32,

Operation bitwise_op);

TNode<Number> BitwiseSmiOp(TNode<Smi> left32, TNode<Smi> right32,

Operation bitwise_op);

// Align the value to kObjectAlignment8GbHeap if V8_COMPRESS_POINTERS_8GB is

// defined.

TNode<IntPtrT> AlignToAllocationAlignment(TNode<IntPtrT> value);

// Allocate an object of the given size.

TNode<HeapObject> AllocateInNewSpace(

TNode<IntPtrT> size, AllocationFlags flags = AllocationFlag::kNone);

TNode<HeapObject> AllocateInNewSpace(

int size, AllocationFlags flags = AllocationFlag::kNone);

TNode<HeapObject> Allocate(TNode<IntPtrT> size,

AllocationFlags flags = AllocationFlag::kNone);

TNode<HeapObject> Allocate(int size,

AllocationFlags flags = AllocationFlag::kNone);

TNode<BoolT> IsRegularHeapObjectSize(TNode<IntPtrT> size);

using BranchGenerator = std::function<void(Label*, Label*)>;

template <typename T>

using NodeGenerator = std::function<TNode<T>()>;

using ExtraNode = std::pair<TNode<Object>, const char*>;

void Dcheck(const BranchGenerator& branch, const char* message,

std::initializer_list<ExtraNode> extra_nodes = {},

SourceLocation loc = SourceLocation::Current());

void Dcheck(const NodeGenerator<BoolT>& condition_body, const char* message,

std::initializer_list<ExtraNode> extra_nodes = {},

SourceLocation loc = SourceLocation::Current());

void Dcheck(TNode<Word32T> condition_node, const char* message,

std::initializer_list<ExtraNode> extra_nodes = {},

SourceLocation loc = SourceLocation::Current());

void Check(const BranchGenerator& branch, const char* message,

std::initializer_list<ExtraNode> extra_nodes = {},

SourceLocation loc = SourceLocation::Current());

void Check(const NodeGenerator<BoolT>& condition_body, const char* message,

std::initializer_list<ExtraNode> extra_nodes = {},

SourceLocation loc = SourceLocation::Current());

void Check(TNode<Word32T> condition_node, const char* message,

std::initializer_list<ExtraNode> extra_nodes = {},

SourceLocation loc = SourceLocation::Current());

void FailAssert(const char* message,

const std::vector<FileAndLine>& files_and_lines,

std::initializer_list<ExtraNode> extra_nodes = {});

void FastCheck(TNode<BoolT> condition);

TNode<RawPtrT> LoadCodeInstructionStart(TNode<Code> code,

CodeEntrypointTag tag);

TNode<BoolT> IsMarkedForDeoptimization(TNode<Code> code);

void DCheckReceiver(ConvertReceiverMode mode, TNode<JSAny> receiver);

// The following Call wrappers call an object according to the semantics that

// one finds in the ECMAScript spec, operating on a Callable (e.g. a

// JSFunction or proxy) rather than an InstructionStream object.

template <typename TCallable, class... TArgs>

inline TNode<JSAny> Call(TNode<Context> context, TNode<TCallable> callable,

ConvertReceiverMode mode, TNode<JSAny> receiver,

TArgs... args);

template <typename TCallable, class... TArgs>

inline TNode<JSAny> Call(TNode<Context> context, TNode<TCallable> callable,

TNode<JSReceiver> receiver, TArgs... args);

template <typename TCallable, class... TArgs>

inline TNode<JSAny> Call(TNode<Context> context, TNode<TCallable> callable,

TNode<JSAny> receiver, TArgs... args);

template <class... TArgs>

inline TNode<JSAny> CallFunction(TNode<Context> context,

TNode<JSFunction> callable,

ConvertReceiverMode mode,

TNode<JSAny> receiver, TArgs... args);

template <class... TArgs>

inline TNode<JSAny> CallFunction(TNode<Context> context,

TNode<JSFunction> callable,

TNode<JSReceiver> receiver, TArgs... args);

template <class... TArgs>

inline TNode<JSAny> CallFunction(TNode<Context> context,

TNode<JSFunction> callable,

TNode<JSAny> receiver, TArgs... args);

TNode<Object> CallApiCallback(TNode<Object> context, TNode<RawPtrT> callback,

TNode<Int32T> argc, TNode<Object> data,

TNode<Object> holder, TNode<JSAny> receiver);

TNode<Object> CallApiCallback(TNode<Object> context, TNode<RawPtrT> callback,

TNode<Int32T> argc, TNode<Object> data,

TNode<Object> holder, TNode<JSAny> receiver,

TNode<Object> value);

TNode<Object> CallRuntimeNewArray(TNode<Context> context,

TNode<JSAny> receiver, TNode<Object> length,

TNode<Object> new_target,

TNode<Object> allocation_site);

void TailCallRuntimeNewArray(TNode<Context> context, TNode<JSAny> receiver,

TNode<Object> length, TNode<Object> new_target,

TNode<Object> allocation_site);

template <class... TArgs>

TNode<JSReceiver> ConstructWithTarget(TNode<Context> context,

TNode<JSReceiver> target,

TNode<JSReceiver> new_target,

TArgs... args) {

return CAST(ConstructJS(Builtin::kConstruct, context, target, new_target,

implicit_cast<TNode<Object>>(args)...));

}

template <class... TArgs>

TNode<JSReceiver> Construct(TNode<Context> context,

TNode<JSReceiver> new_target, TArgs... args) {

return ConstructWithTarget(context, new_target, new_target, args...);

}

template <typename T>

TNode<T> Select(TNode<BoolT> condition, const NodeGenerator<T>& true_body,

const NodeGenerator<T>& false_body,

BranchHint branch_hint = BranchHint::kNone) {

TVARIABLE(T, value);

Label vtrue(this), vfalse(this), end(this);

Branch(condition, &vtrue, &vfalse, branch_hint);

BIND(&vtrue);

{

value = true_body();

Goto(&end);

}

BIND(&vfalse);

{

value = false_body();

Goto(&end);

}

BIND(&end);

return value.value();

}

template <class A>

TNode<A> SelectConstant(TNode<BoolT> condition, TNode<A> true_value,

TNode<A> false_value) {

return Select<A>(

condition, [=] { return true_value; }, [=] { return false_value; });

}

TNode<Int32T> SelectInt32Constant(TNode<BoolT> condition, int true_value,

int false_value);

TNode<IntPtrT> SelectIntPtrConstant(TNode<BoolT> condition, int true_value,

int false_value);

TNode<Boolean> SelectBooleanConstant(TNode<BoolT> condition);

TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, Tagged<Smi> true_value,

Tagged<Smi> false_value);

TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, int true_value,

Tagged<Smi> false_value) {

return SelectSmiConstant(condition, Smi::FromInt(true_value), false_value);

}

TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, Tagged<Smi> true_value,

int false_value) {

return SelectSmiConstant(condition, true_value, Smi::FromInt(false_value));

}

TNode<Smi> SelectSmiConstant(TNode<BoolT> condition, int true_value,

int false_value) {

return SelectSmiConstant(condition, Smi::FromInt(true_value),

Smi::FromInt(false_value));

}

TNode<String> SingleCharacterStringConstant(char const* single_char) {

DCHECK_EQ(strlen(single_char), 1);

DCHECK_LE(single_char[0], String::kMaxOneByteCharCode);

return HeapConstantNoHole(

isolate()->factory()->LookupSingleCharacterStringFromCode(

single_char[0]));

}

TNode<Float16RawBitsT> TruncateFloat32ToFloat16(TNode<Float32T> value);

TNode<Float16RawBitsT> TruncateFloat64ToFloat16(TNode<Float64T> value);

TNode<Int32T> TruncateWordToInt32(TNode<WordT> value);

TNode<Int32T> TruncateIntPtrToInt32(TNode<IntPtrT> value);

TNode<Word32T> TruncateWord64ToWord32(TNode<Word64T> value);

// Check a value for smi-ness

TNode<BoolT> TaggedIsSmi(TNode<MaybeObject> a);

TNode<BoolT> TaggedIsNotSmi(TNode<MaybeObject> a);

// Check a value for HeapObject-ness (for a heap object tag bit).

TNode<BoolT> TaggedIsStrongHeapObject(TNode<MaybeObject> a);

TNode<BoolT> TaggedIsNotStrongHeapObject(TNode<MaybeObject> a);

// Check that the value is a non-negative smi.

TNode<BoolT> TaggedIsPositiveSmi(TNode<Object> a);

// Check that a word has a word-aligned address.

TNode<BoolT> WordIsAligned(TNode<WordT> word, size_t alignment);

TNode<BoolT> WordIsPowerOfTwo(TNode<IntPtrT> value);

TNode<BoolT> TaggedIsNotInterceptedSentinel(TNode<Object> a);

// Check if lower_limit <= value <= higher_limit.

template <typename U>

TNode<BoolT> IsInRange(TNode<Word32T> value, U lower_limit, U higher_limit) {

DCHECK_LE(lower_limit, higher_limit);

static_assert(sizeof(U) <= kInt32Size);

if (lower_limit == 0) {

return Uint32LessThanOrEqual(value, Int32Constant(higher_limit));

}

return Uint32LessThanOrEqual(Int32Sub(value, Int32Constant(lower_limit)),

Int32Constant(higher_limit - lower_limit));

}

TNode<BoolT> IsInRange(TNode<UintPtrT> value, TNode<UintPtrT> lower_limit,

TNode<UintPtrT> higher_limit) {

CSA_DCHECK(this, UintPtrLessThanOrEqual(lower_limit, higher_limit));

return UintPtrLessThanOrEqual(UintPtrSub(value, lower_limit),

UintPtrSub(higher_limit, lower_limit));

}

TNode<BoolT> IsInRange(TNode<WordT> value, intptr_t lower_limit,

intptr_t higher_limit) {

DCHECK_LE(lower_limit, higher_limit);

if (lower_limit == 0) {

return UintPtrLessThanOrEqual(value, IntPtrConstant(higher_limit));

}

return UintPtrLessThanOrEqual(IntPtrSub(value, IntPtrConstant(lower_limit)),

IntPtrConstant(higher_limit - lower_limit));

}

#if DEBUG

void Bind(Label* label, AssemblerDebugInfo debug_info);

#endif // DEBUG

void Bind(Label* label);

template <class... T>

void Bind(compiler::CodeAssemblerParameterizedLabel<T...>* label,

TNode<T>*... phis) {

CodeAssembler::Bind(label, phis...);

}

void BranchIfSmiEqual(TNode<Smi> a, TNode<Smi> b, Label* if_true,

Label* if_false) {

Branch(SmiEqual(a, b), if_true, if_false);

}

void BranchIfSmiLessThan(TNode<Smi> a, TNode<Smi> b, Label* if_true,

Label* if_false) {

Branch(SmiLessThan(a, b), if_true, if_false);

}

void BranchIfSmiLessThanOrEqual(TNode<Smi> a, TNode<Smi> b, Label* if_true,

Label* if_false) {

Branch(SmiLessThanOrEqual(a, b), if_true, if_false);

}

void BranchIfFloat64IsNaN(TNode<Float64T> value, Label* if_true,

Label* if_false) {

Branch(Float64Equal(value, value), if_false, if_true);

}

// Branches to {if_true} if ToBoolean applied to {value} yields true,

// otherwise goes to {if_false}.

void BranchIfToBooleanIsTrue(TNode<Object> value, Label* if_true,

Label* if_false) {

BranchIfToBooleanIsTrue(value, false, if_true, if_false);

}

// Branches to {if_true} if ToBoolean applied to {value} yields true,

// otherwise goes to {if_false}. Optionally skips the check for Smi values

// and static root values, in case those are inlined.

void BranchIfToBooleanIsTrue(TNode<Object> value,

bool skip_smi_and_static_root_check,

Label* if_true, Label* if_false);

// Branches to {if_false} if ToBoolean applied to {value} yields false,

// otherwise goes to {if_true}.

void BranchIfToBooleanIsFalse(TNode<Object> value, Label* if_false,

Label* if_true) {

BranchIfToBooleanIsTrue(value, if_true, if_false);

}

void BranchIfJSReceiver(TNode<Object> object, Label* if_true,

Label* if_false);

// Branches to {if_true} when --force-slow-path flag has been passed.

// It's used for testing to ensure that slow path implementation behave

// equivalent to corresponding fast paths (where applicable).

//

// Works only with V8_ENABLE_FORCE_SLOW_PATH compile time flag. Nop otherwise.

void GotoIfForceSlowPath(Label* if_true);

//

// Sandboxed pointer related functionality.

//

// Load a sandboxed pointer value from an object.

TNode<RawPtrT> LoadSandboxedPointerFromObject(TNode<HeapObject> object,

int offset) {

return LoadSandboxedPointerFromObject(object, IntPtrConstant(offset));

}

TNode<RawPtrT> LoadSandboxedPointerFromObject(TNode<HeapObject> object,

TNode<IntPtrT> offset);

// Stored a sandboxed pointer value to an object.

void StoreSandboxedPointerToObject(TNode<HeapObject> object, int offset,

TNode<RawPtrT> pointer) {

StoreSandboxedPointerToObject(object, IntPtrConstant(offset), pointer);

}

void StoreSandboxedPointerToObject(TNode<HeapObject> object,

TNode<IntPtrT> offset,

TNode<RawPtrT> pointer);

TNode<RawPtrT> EmptyBackingStoreBufferConstant();

//

// Bounded size related functionality.

//

// Load a bounded size value from an object.

TNode<UintPtrT> LoadBoundedSizeFromObject(TNode<HeapObject> object,

int offset) {

return LoadBoundedSizeFromObject(object, IntPtrConstant(offset));

}

TNode<UintPtrT> LoadBoundedSizeFromObject(TNode<HeapObject> object,

TNode<IntPtrT> offset);

// Stored a bounded size value to an object.

void StoreBoundedSizeToObject(TNode<HeapObject> object, int offset,

TNode<UintPtrT> value) {

StoreBoundedSizeToObject(object, IntPtrConstant(offset), value);

}

void StoreBoundedSizeToObject(TNode<HeapObject> object, TNode<IntPtrT> offset,

TNode<UintPtrT> value);

//

// ExternalPointerT-related functionality.

//

TNode<RawPtrT> ExternalPointerTableAddress(ExternalPointerTagRange tag_range);

// Load an external pointer value from an object.

TNode<RawPtrT> LoadExternalPointerFromObject(

TNode<HeapObject> object, int offset, ExternalPointerTagRange tag_range) {

return LoadExternalPointerFromObject(object, IntPtrConstant(offset),

tag_range);

}

TNode<RawPtrT> LoadExternalPointerFromObject(

TNode<HeapObject> object, TNode<IntPtrT> offset,

ExternalPointerTagRange tag_range);

// Store external object pointer to object.

void StoreExternalPointerToObject(TNode<HeapObject> object, int offset,

TNode<RawPtrT> pointer,

ExternalPointerTag tag) {

StoreExternalPointerToObject(object, IntPtrConstant(offset), pointer, tag);

}

void StoreExternalPointerToObject(TNode<HeapObject> object,

TNode<IntPtrT> offset,

TNode<RawPtrT> pointer,

ExternalPointerTag tag);