// 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 "src/base/macros.h"

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

#include "src/common/external-pointer.h"

#include "src/common/globals.h"

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

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

#include "src/objects/arguments.h"

#include "src/objects/bigint.h"

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

#include "src/objects/objects.h"

#include "src/objects/promise.h"

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

#include "src/objects/smi.h"

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

#include "src/roots/roots.h"

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

namespace v8 {

namespace internal {

class CallInterfaceDescriptor;

class CodeStubArguments;

class CodeStubAssembler;

class StatsCounter;

class StubCache;

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

#define HEAP_MUTABLE_IMMOVABLE_OBJECT_LIST(V) \

V(ArrayIteratorProtector, array_iterator_protector, ArrayIteratorProtector) \

V(ArraySpeciesProtector, array_species_protector, ArraySpeciesProtector) \

V(AsyncFunctionAwaitRejectSharedFun, async_function_await_reject_shared_fun, \

AsyncFunctionAwaitRejectSharedFun) \

V(AsyncFunctionAwaitResolveSharedFun, \

async_function_await_resolve_shared_fun, \

AsyncFunctionAwaitResolveSharedFun) \

V(AsyncGeneratorAwaitRejectSharedFun, \

async_generator_await_reject_shared_fun, \

AsyncGeneratorAwaitRejectSharedFun) \

V(AsyncGeneratorAwaitResolveSharedFun, \

async_generator_await_resolve_shared_fun, \

AsyncGeneratorAwaitResolveSharedFun) \

V(AsyncGeneratorReturnClosedRejectSharedFun, \

async_generator_return_closed_reject_shared_fun, \

AsyncGeneratorReturnClosedRejectSharedFun) \

V(AsyncGeneratorReturnClosedResolveSharedFun, \

async_generator_return_closed_resolve_shared_fun, \

AsyncGeneratorReturnClosedResolveSharedFun) \

V(AsyncGeneratorReturnResolveSharedFun, \

async_generator_return_resolve_shared_fun, \

AsyncGeneratorReturnResolveSharedFun) \

V(AsyncGeneratorYieldResolveSharedFun, \

async_generator_yield_resolve_shared_fun, \

AsyncGeneratorYieldResolveSharedFun) \

V(AsyncIteratorValueUnwrapSharedFun, async_iterator_value_unwrap_shared_fun, \

AsyncIteratorValueUnwrapSharedFun) \

V(MapIteratorProtector, map_iterator_protector, MapIteratorProtector) \

V(NoElementsProtector, no_elements_protector, NoElementsProtector) \

V(NumberStringCache, number_string_cache, NumberStringCache) \

V(PromiseAllResolveElementSharedFun, promise_all_resolve_element_shared_fun, \

PromiseAllResolveElementSharedFun) \

V(PromiseAllSettledRejectElementSharedFun, \

promise_all_settled_reject_element_shared_fun, \

PromiseAllSettledRejectElementSharedFun) \

V(PromiseAllSettledResolveElementSharedFun, \

promise_all_settled_resolve_element_shared_fun, \

PromiseAllSettledResolveElementSharedFun) \

V(PromiseAnyRejectElementSharedFun, promise_any_reject_element_shared_fun, \

PromiseAnyRejectElementSharedFun) \

V(PromiseCapabilityDefaultRejectSharedFun, \

promise_capability_default_reject_shared_fun, \

PromiseCapabilityDefaultRejectSharedFun) \

V(PromiseCapabilityDefaultResolveSharedFun, \

promise_capability_default_resolve_shared_fun, \

PromiseCapabilityDefaultResolveSharedFun) \

V(PromiseCatchFinallySharedFun, promise_catch_finally_shared_fun, \

PromiseCatchFinallySharedFun) \

V(PromiseGetCapabilitiesExecutorSharedFun, \

promise_get_capabilities_executor_shared_fun, \

PromiseGetCapabilitiesExecutorSharedFun) \

V(PromiseResolveProtector, promise_resolve_protector, \

PromiseResolveProtector) \

V(PromiseSpeciesProtector, promise_species_protector, \

PromiseSpeciesProtector) \

V(PromiseThenFinallySharedFun, promise_then_finally_shared_fun, \

PromiseThenFinallySharedFun) \

V(PromiseThenProtector, promise_then_protector, PromiseThenProtector) \

V(PromiseThrowerFinallySharedFun, promise_thrower_finally_shared_fun, \

PromiseThrowerFinallySharedFun) \

V(PromiseValueThunkFinallySharedFun, promise_value_thunk_finally_shared_fun, \

PromiseValueThunkFinallySharedFun) \

V(ProxyRevokeSharedFun, proxy_revoke_shared_fun, ProxyRevokeSharedFun) \

V(RegExpSpeciesProtector, regexp_species_protector, RegExpSpeciesProtector) \

V(SetIteratorProtector, set_iterator_protector, SetIteratorProtector) \

V(SingleCharacterStringCache, single_character_string_cache, \

SingleCharacterStringCache) \

V(StringIteratorProtector, string_iterator_protector, \

StringIteratorProtector) \

V(TypedArraySpeciesProtector, typed_array_species_protector, \

TypedArraySpeciesProtector)

#define UNIQUE_INSTANCE_TYPE_IMMUTABLE_IMMOVABLE_MAP_ADAPTER( \

V, rootIndexName, rootAccessorName, class_name) \

V(rootIndexName, rootAccessorName, class_name##Map)

#define HEAP_IMMUTABLE_IMMOVABLE_OBJECT_LIST(V) \

V(AllocationSiteWithoutWeakNextMap, allocation_site_without_weaknext_map, \

AllocationSiteWithoutWeakNextMap) \

V(AllocationSiteWithWeakNextMap, allocation_site_map, AllocationSiteMap) \

V(arguments_to_string, arguments_to_string, ArgumentsToString) \

V(Array_string, Array_string, ArrayString) \

V(array_to_string, array_to_string, ArrayToString) \

V(BooleanMap, boolean_map, BooleanMap) \

V(boolean_to_string, boolean_to_string, BooleanToString) \

V(ConsOneByteStringMap, cons_one_byte_string_map, ConsOneByteStringMap) \

V(ConsStringMap, cons_string_map, ConsStringMap) \

V(constructor_string, constructor_string, ConstructorString) \

V(date_to_string, date_to_string, DateToString) \

V(default_string, default_string, DefaultString) \

V(EmptyByteArray, empty_byte_array, EmptyByteArray) \

V(EmptyFixedArray, empty_fixed_array, EmptyFixedArray) \

V(EmptyPropertyDictionary, empty_property_dictionary, \

EmptyPropertyDictionary) \

V(EmptySlowElementDictionary, empty_slow_element_dictionary, \

EmptySlowElementDictionary) \

V(empty_string, empty_string, EmptyString) \

V(error_to_string, error_to_string, ErrorToString) \

V(errors_string, errors_string, ErrorsString) \

V(FalseValue, false_value, False) \

V(FixedArrayMap, fixed_array_map, FixedArrayMap) \

V(FixedCOWArrayMap, fixed_cow_array_map, FixedCOWArrayMap) \

V(Function_string, function_string, FunctionString) \

V(function_to_string, function_to_string, FunctionToString) \

V(GlobalPropertyCellMap, global_property_cell_map, PropertyCellMap) \

V(has_instance_symbol, has_instance_symbol, HasInstanceSymbol) \

V(Infinity_string, Infinity_string, InfinityString) \

V(is_concat_spreadable_symbol, is_concat_spreadable_symbol, \

IsConcatSpreadableSymbol) \

V(iterator_symbol, iterator_symbol, IteratorSymbol) \

V(length_string, length_string, LengthString) \

V(ManyClosuresCellMap, many_closures_cell_map, ManyClosuresCellMap) \

V(match_symbol, match_symbol, MatchSymbol) \

V(megamorphic_symbol, megamorphic_symbol, MegamorphicSymbol) \

V(message_string, message_string, MessageString) \

V(minus_Infinity_string, minus_Infinity_string, MinusInfinityString) \

V(MinusZeroValue, minus_zero_value, MinusZero) \

V(name_string, name_string, NameString) \

V(NanValue, nan_value, Nan) \

V(NaN_string, NaN_string, NaNString) \

V(next_string, next_string, NextString) \

V(NoClosuresCellMap, no_closures_cell_map, NoClosuresCellMap) \

V(null_to_string, null_to_string, NullToString) \

V(NullValue, null_value, Null) \

V(number_string, number_string, NumberString) \

V(number_to_string, number_to_string, NumberToString) \

V(Object_string, Object_string, ObjectString) \

V(object_to_string, object_to_string, ObjectToString) \

V(OneByteStringMap, one_byte_string_map, OneByteStringMap) \

V(OneClosureCellMap, one_closure_cell_map, OneClosureCellMap) \

V(OnePointerFillerMap, one_pointer_filler_map, OnePointerFillerMap) \

V(PromiseCapabilityMap, promise_capability_map, PromiseCapabilityMap) \

V(promise_forwarding_handler_symbol, promise_forwarding_handler_symbol, \

PromiseForwardingHandlerSymbol) \

V(PromiseFulfillReactionJobTaskMap, promise_fulfill_reaction_job_task_map, \

PromiseFulfillReactionJobTaskMap) \

V(promise_handled_by_symbol, promise_handled_by_symbol, \

PromiseHandledBySymbol) \

V(PromiseReactionMap, promise_reaction_map, PromiseReactionMap) \

V(PromiseRejectReactionJobTaskMap, promise_reject_reaction_job_task_map, \

PromiseRejectReactionJobTaskMap) \

V(PromiseResolveThenableJobTaskMap, promise_resolve_thenable_job_task_map, \

PromiseResolveThenableJobTaskMap) \

V(prototype_string, prototype_string, PrototypeString) \

V(replace_symbol, replace_symbol, ReplaceSymbol) \

V(regexp_to_string, regexp_to_string, RegexpToString) \

V(resolve_string, resolve_string, ResolveString) \

V(return_string, return_string, ReturnString) \

V(species_symbol, species_symbol, SpeciesSymbol) \

V(StaleRegister, stale_register, StaleRegister) \

V(StoreHandler0Map, store_handler0_map, StoreHandler0Map) \

V(string_string, string_string, StringString) \

V(string_to_string, string_to_string, StringToString) \

V(StringMap, string_map, StringMap) \

V(TheHoleValue, the_hole_value, TheHole) \

V(then_string, then_string, ThenString) \

V(toString_string, toString_string, ToStringString) \

V(to_primitive_symbol, to_primitive_symbol, ToPrimitiveSymbol) \

V(to_string_tag_symbol, to_string_tag_symbol, ToStringTagSymbol) \

V(TrueValue, true_value, True) \

V(undefined_to_string, undefined_to_string, UndefinedToString) \

V(UndefinedValue, undefined_value, Undefined) \

V(uninitialized_symbol, uninitialized_symbol, UninitializedSymbol) \

V(valueOf_string, valueOf_string, ValueOfString) \

V(zero_string, zero_string, ZeroString) \

UNIQUE_INSTANCE_TYPE_MAP_LIST_GENERATOR( \

UNIQUE_INSTANCE_TYPE_IMMUTABLE_IMMOVABLE_MAP_ADAPTER, V)

#define HEAP_IMMOVABLE_OBJECT_LIST(V) \

HEAP_MUTABLE_IMMOVABLE_OBJECT_LIST(V) \

HEAP_IMMUTABLE_IMMOVABLE_OBJECT_LIST(V)

#ifdef DEBUG

#define CSA_CHECK(csa, x) \

(csa)->Check([&]() -> TNode<BoolT> { return x; }, #x, __FILE__, __LINE__)

#else

#define CSA_CHECK(csa, x) (csa)->FastCheck(x)

#endif

#ifdef DEBUG

// CSA_ASSERT_ARGS generates an

// std::initializer_list<CodeStubAssembler::ExtraNode> from __VA_ARGS__. It

// currently supports between 0 and 2 arguments.

// clang-format off

#define CSA_ASSERT_0_ARGS(...) {}

#define CSA_ASSERT_1_ARG(a, ...) {{a, #a}}

#define CSA_ASSERT_2_ARGS(a, b, ...) {{a, #a}, {b, #b}}

// clang-format on

#define SWITCH_CSA_ASSERT_ARGS(dummy, a, b, FUNC, ...) FUNC(a, b)

#define CSA_ASSERT_ARGS(...) \

CALL(SWITCH_CSA_ASSERT_ARGS, (, ##__VA_ARGS__, CSA_ASSERT_2_ARGS, \

CSA_ASSERT_1_ARG, CSA_ASSERT_0_ARGS))

// Workaround for MSVC to skip comma in empty __VA_ARGS__.

#define CALL(x, y) x y

// CSA_ASSERT(csa, <condition>, <extra values to print...>)

#define CSA_ASSERT(csa, condition_node, ...) \

(csa)->Assert(condition_node, #condition_node, __FILE__, __LINE__, \

CSA_ASSERT_ARGS(__VA_ARGS__))

// CSA_ASSERT_BRANCH(csa, [](Label* ok, Label* not_ok) {...},

// <extra values to print...>)

#define CSA_ASSERT_BRANCH(csa, gen, ...) \

(csa)->Assert(gen, #gen, __FILE__, __LINE__, CSA_ASSERT_ARGS(__VA_ARGS__))

#define CSA_ASSERT_JS_ARGC_OP(csa, Op, op, expected) \

(csa)->Assert( \

[&]() -> TNode<BoolT> { \

const TNode<Word32T> argc = UncheckedCast<Word32T>( \

(csa)->Parameter(Descriptor::kJSActualArgumentsCount)); \

return (csa)->Op(argc, (csa)->Int32Constant(expected)); \

}, \

"argc " #op " " #expected, __FILE__, __LINE__, \

{{SmiFromInt32((csa)->Parameter(Descriptor::kJSActualArgumentsCount)), \

"argc"}})

#define CSA_ASSERT_JS_ARGC_EQ(csa, expected) \

CSA_ASSERT_JS_ARGC_OP(csa, Word32Equal, ==, expected)

#define CSA_DEBUG_INFO(name) \

{ #name, __FILE__, __LINE__ }

#define BIND(label) Bind(label, CSA_DEBUG_INFO(label))

#define TYPED_VARIABLE_DEF(type, name, ...) \

TVariable<type> name(CSA_DEBUG_INFO(name), __VA_ARGS__)

#define TYPED_VARIABLE_CONSTRUCTOR(name, ...) \

name(CSA_DEBUG_INFO(name), __VA_ARGS__)

#else // DEBUG

#define CSA_ASSERT(csa, ...) ((void)0)

#define CSA_ASSERT_BRANCH(csa, ...) ((void)0)

#define CSA_ASSERT_JS_ARGC_EQ(csa, expected) ((void)0)

#define BIND(label) Bind(label)

#define TYPED_VARIABLE_DEF(type, name, ...) TVariable<type> name(__VA_ARGS__)

#define TYPED_VARIABLE_CONSTRUCTOR(name, ...) name(__VA_ARGS__)

#endif // DEBUG

#define TVARIABLE(...) EXPAND(TYPED_VARIABLE_DEF(__VA_ARGS__, this))

#define TVARIABLE_CONSTRUCTOR(...) \

EXPAND(TYPED_VARIABLE_CONSTRUCTOR(__VA_ARGS__, this))

#ifdef ENABLE_SLOW_DCHECKS

#define CSA_SLOW_ASSERT(csa, ...) \

if (FLAG_enable_slow_asserts) { \

CSA_ASSERT(csa, __VA_ARGS__); \

}

#else

#define CSA_SLOW_ASSERT(csa, ...) ((void)0)

#endif

// 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 Node = compiler::Node;

using ScopedExceptionHandler = compiler::ScopedExceptionHandler;

template <typename T>

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

explicit CodeStubAssembler(compiler::CodeAssemblerState* state);

enum AllocationFlag : uint8_t {

kNone = 0,

kDoubleAlignment = 1,

kPretenured = 1 << 1,

kAllowLargeObjectAllocation = 1 << 2,

};

enum SlackTrackingMode { kWithSlackTracking, kNoSlackTracking };

using AllocationFlags = base::Flags<AllocationFlag>;

enum ParameterMode { SMI_PARAMETERS, INTPTR_PARAMETERS };

// On 32-bit platforms, there is a slight performance advantage to doing all

// of the array offset/index arithmetic with SMIs, since it's possible

// to save a few tag/untag operations without paying an extra expense when

// calculating array offset (the smi math can be folded away) and there are

// fewer live ranges. Thus only convert indices to untagged value on 64-bit

// platforms.

ParameterMode OptimalParameterMode() const {

#if defined(BINT_IS_SMI)

return SMI_PARAMETERS;

#elif defined(BINT_IS_INTPTR)

return INTPTR_PARAMETERS;

#else

#error Unknown BInt type.

#endif

}

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

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

// TODO(v8:9708): remove once all uses are ported.

TNode<IntPtrT> ParameterToIntPtr(Node* value, ParameterMode mode) {

if (mode == SMI_PARAMETERS) value = SmiUntag(value);

return UncheckedCast<IntPtrT>(value);

}

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

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

TNode<Smi> ParameterToTagged(Node* value, ParameterMode mode) {

if (mode != SMI_PARAMETERS) return SmiTag(value);

return UncheckedCast<Smi>(value);

}

template <typename TIndex>

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

// TODO(v8:9708): remove once all uses are ported.

Node* TaggedToParameter(TNode<Smi> value, ParameterMode mode) {

if (mode != SMI_PARAMETERS) return SmiUntag(value);

return value;

}

bool ToParameterConstant(Node* node, intptr_t* out, ParameterMode mode) {

if (mode == ParameterMode::SMI_PARAMETERS) {

Smi constant;

if (ToSmiConstant(node, &constant)) {

*out = static_cast<intptr_t>(constant.value());

return true;

}

} else {

DCHECK_EQ(mode, ParameterMode::INTPTR_PARAMETERS);

intptr_t constant;

if (ToIntPtrConstant(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

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

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

// TODO(v8:10047): Get rid of these convertions 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<JSReceiver> 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);

}

Node* MatchesParameterMode(Node* value, ParameterMode mode);

#define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName) \

/* TODO(v8:9708): remove once all uses are ported. */ \

Node* OpName(Node* a, Node* b, ParameterMode mode) { \

if (mode == SMI_PARAMETERS) { \

return SmiOpName(CAST(a), CAST(b)); \

} else { \

DCHECK_EQ(INTPTR_PARAMETERS, mode); \

return IntPtrOpName(UncheckedCast<IntPtrT>(a), \

UncheckedCast<IntPtrT>(b)); \

} \

} \

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(IntPtrOrSmiMin, IntPtrMin, SmiMin)

PARAMETER_BINOP(IntPtrOrSmiAdd, IntPtrAdd, SmiAdd)

PARAMETER_BINOP(IntPtrOrSmiSub, IntPtrSub, SmiSub)

#undef PARAMETER_BINOP

#define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName) \

/* TODO(v8:9708): remove once all uses are ported. */ \

TNode<BoolT> OpName(Node* a, Node* b, ParameterMode mode) { \

if (mode == SMI_PARAMETERS) { \

return SmiOpName(CAST(a), CAST(b)); \

} else { \

DCHECK_EQ(INTPTR_PARAMETERS, mode); \

return IntPtrOpName(UncheckedCast<IntPtrT>(a), \

UncheckedCast<IntPtrT>(b)); \

} \

} \

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); \

} \

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

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

} \

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

return IntPtrOpName(a, b); \

}

// 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)

PARAMETER_BINOP(IntPtrOrSmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual,

SmiGreaterThanOrEqual)

PARAMETER_BINOP(UintPtrOrSmiLessThan, UintPtrLessThan, SmiBelow)

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; }

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

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) {

return Word32BinaryNot(TaggedEqual(a, b));

}

TNode<Smi> NoContextConstant();

#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name) \

TNode<std::remove_pointer<std::remove_reference<decltype( \

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

name##Constant();

HEAP_IMMUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR)

#undef HEAP_CONSTANT_ACCESSOR

#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name) \

TNode<std::remove_pointer<std::remove_reference<decltype( \

std::declval<Heap>().rootAccessorName())>::type>::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(SloppyTNode<Object> value); \

TNode<BoolT> IsNot##name(SloppyTNode<Object> value);

HEAP_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_TEST)

#undef HEAP_CONSTANT_TEST

TNode<BInt> BIntConstant(int value);

template <typename TIndex>

TNode<TIndex> IntPtrOrSmiConstant(int value);

// TODO(v8:9708): remove once all uses are ported.

Node* IntPtrOrSmiConstant(int value, ParameterMode mode);

bool TryGetIntPtrOrSmiConstantValue(Node* maybe_constant, int* value,

ParameterMode mode);

// 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(SloppyTNode<IntPtrT> left,

SloppyTNode<IntPtrT> right);

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

TNode<IntPtrT> IntPtrMin(SloppyTNode<IntPtrT> left,

SloppyTNode<IntPtrT> right);

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

// Float64 operations.

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

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

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

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

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

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

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

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

TNode<Number> NumberMin(SloppyTNode<Number> left, SloppyTNode<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(SloppyTNode<IntPtrT> value);

// Untag a Smi value as an IntPtr.

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

// Smi conversions.

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

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

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

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

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

TNode<Int32T> SmiToInt32(SloppyTNode<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)

#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<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> SmiShl(TNode<Smi> a, int shift) {

return BitcastWordToTaggedSigned(

WordShl(BitcastTaggedToWordForTagAndSmiBits(a), shift));

}

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

if (kTaggedSize == kInt64Size) {

return 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.

return BitcastWordToTaggedSigned(WordAnd(

ChangeInt32ToIntPtr(Word32Shr(

TruncateWordToInt32(BitcastTaggedToWordForTagAndSmiBits(a)),

shift)),

BitcastTaggedToWordForTagAndSmiBits(SmiConstant(-1))));

}

}

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

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))));

}

}

Node* WordOrSmiShr(Node* a, int shift, ParameterMode mode) {

if (mode == SMI_PARAMETERS) {

return SmiShr(CAST(a), shift);

} else {

DCHECK_EQ(INTPTR_PARAMETERS, mode);

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(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);

#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(SloppyTNode<Number> value);

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

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

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

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

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

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

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

Operation bitwise_op);

// Allocate an object of the given size.

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

AllocationFlags flags = kNone);

TNode<HeapObject> AllocateInNewSpace(int size, AllocationFlags flags = kNone);

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

AllocationFlags flags = kNone);

TNode<HeapObject> Allocate(int size, AllocationFlags flags = kNone);

TNode<HeapObject> InnerAllocate(TNode<HeapObject> previous, int offset);

TNode<HeapObject> InnerAllocate(TNode<HeapObject> previous,

TNode<IntPtrT> offset);

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 Assert(const BranchGenerator& branch, const char* message,

const char* file, int line,

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

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

const char* file, int line,

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

void Assert(SloppyTNode<Word32T> condition_node, const char* message,

const char* file, int line,

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

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

const char* file, int line,

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

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

const char* file, int line,

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

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

const char* file, int line,

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

void FailAssert(const char* message, const char* file, int line,

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

void FastCheck(TNode<BoolT> condition);

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

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

// JSFunction or proxy) rather than a Code object.

template <class... TArgs>

TNode<Object> Call(TNode<Context> context, TNode<Object> callable,

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

return UncheckedCast<Object>(CallJS(

CodeFactory::Call(isolate(), ConvertReceiverMode::kNotNullOrUndefined),

context, callable, receiver, args...));

}

template <class... TArgs>

TNode<Object> Call(TNode<Context> context, TNode<Object> callable,

TNode<Object> receiver, TArgs... args) {

if (IsUndefinedConstant(receiver) || IsNullConstant(receiver)) {

return UncheckedCast<Object>(CallJS(

CodeFactory::Call(isolate(), ConvertReceiverMode::kNullOrUndefined),

context, callable, receiver, args...));

}

return UncheckedCast<Object>(CallJS(CodeFactory::Call(isolate()), context,

callable, receiver, args...));

}

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

TNode<IntPtrT> argc, TNode<Object> data,

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

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

TNode<IntPtrT> argc, TNode<Object> data,

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

TNode<Object> value);

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

TNode<Object> receiver,

TNode<Object> length,

TNode<Object> new_target,

TNode<Object> allocation_site);

void TailCallRuntimeNewArray(TNode<Context> context, TNode<Object> 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(ConstructJSWithTarget(CodeFactory::Construct(isolate()),

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) {

TVARIABLE(T, value);

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

Branch(condition, &vtrue, &vfalse);

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(SloppyTNode<BoolT> condition,

int true_value, int false_value);

TNode<IntPtrT> SelectIntPtrConstant(SloppyTNode<BoolT> condition,

int true_value, int false_value);

TNode<Oddball> SelectBooleanConstant(SloppyTNode<BoolT> condition);

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

Smi false_value);

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

Smi false_value) {

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

}

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

int false_value) {

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

}

TNode<Smi> SelectSmiConstant(SloppyTNode<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);

return HeapConstant(

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

single_char[0]));

}

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

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

// Check a value for smi-ness

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

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

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

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

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

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

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

// 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);

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

Int32Constant(higher_limit - lower_limit));

}

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

intptr_t higher_limit) {

DCHECK_LE(lower_limit, 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}.