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

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

#include "src/code-factory.h"

#include "src/frames-inl.h"

#include "src/frames.h"

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

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

#include "src/objects/ordered-hash-table-inl.h"

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

namespace v8 {

namespace internal {

using compiler::Node;

template <class T>

using TNode = compiler::TNode<T>;

template <class T>

using SloppyTNode = compiler::SloppyTNode<T>;

CodeStubAssembler::CodeStubAssembler(compiler::CodeAssemblerState* state)

: compiler::CodeAssembler(state) {

if (DEBUG_BOOL && FLAG_csa_trap_on_node != nullptr) {

HandleBreakOnNode();

}

}

void CodeStubAssembler::HandleBreakOnNode() {

// FLAG_csa_trap_on_node should be in a form "STUB,NODE" where STUB is a

// string specifying the name of a stub and NODE is number specifying node id.

const char* name = state()->name();

size_t name_length = strlen(name);

if (strncmp(FLAG_csa_trap_on_node, name, name_length) != 0) {

// Different name.

return;

}

size_t option_length = strlen(FLAG_csa_trap_on_node);

if (option_length < name_length + 2 ||

FLAG_csa_trap_on_node[name_length] != ',') {

// Option is too short.

return;

}

const char* start = &FLAG_csa_trap_on_node[name_length + 1];

char* end;

int node_id = static_cast<int>(strtol(start, &end, 10));

if (start == end) {

// Bad node id.

return;

}

BreakOnNode(node_id);

}

void CodeStubAssembler::Assert(const BranchGenerator& branch,

const char* message, const char* file, int line,

Node* extra_node1, const char* extra_node1_name,

Node* extra_node2, const char* extra_node2_name,

Node* extra_node3, const char* extra_node3_name,

Node* extra_node4, const char* extra_node4_name,

Node* extra_node5,

const char* extra_node5_name) {

#if defined(DEBUG)

if (FLAG_debug_code) {

Check(branch, message, file, line, extra_node1, extra_node1_name,

extra_node2, extra_node2_name, extra_node3, extra_node3_name,

extra_node4, extra_node4_name, extra_node5, extra_node5_name);

}

#endif

}

void CodeStubAssembler::Assert(const NodeGenerator& condition_body,

const char* message, const char* file, int line,

Node* extra_node1, const char* extra_node1_name,

Node* extra_node2, const char* extra_node2_name,

Node* extra_node3, const char* extra_node3_name,

Node* extra_node4, const char* extra_node4_name,

Node* extra_node5,

const char* extra_node5_name) {

#if defined(DEBUG)

if (FLAG_debug_code) {

Check(condition_body, message, file, line, extra_node1, extra_node1_name,

extra_node2, extra_node2_name, extra_node3, extra_node3_name,

extra_node4, extra_node4_name, extra_node5, extra_node5_name);

}

#endif

}

#ifdef DEBUG

namespace {

void MaybePrintNodeWithName(CodeStubAssembler* csa, Node* node,

const char* node_name) {

if (node != nullptr) {

csa->CallRuntime(Runtime::kPrintWithNameForAssert, csa->SmiConstant(0),

csa->StringConstant(node_name), node);

}

}

} // namespace

#endif

void CodeStubAssembler::Check(const BranchGenerator& branch,

const char* message, const char* file, int line,

Node* extra_node1, const char* extra_node1_name,

Node* extra_node2, const char* extra_node2_name,

Node* extra_node3, const char* extra_node3_name,

Node* extra_node4, const char* extra_node4_name,

Node* extra_node5, const char* extra_node5_name) {

Label ok(this);

Label not_ok(this, Label::kDeferred);

if (message != nullptr && FLAG_code_comments) {

Comment("[ Assert: %s", message);

} else {

Comment("[ Assert");

}

branch(&ok, &not_ok);

BIND(&not_ok);

DCHECK_NOT_NULL(message);

char chars[1024];

Vector<char> buffer(chars);

if (file != nullptr) {

SNPrintF(buffer, "CSA_ASSERT failed: %s [%s:%d]\n", message, file, line);

} else {

SNPrintF(buffer, "CSA_ASSERT failed: %s\n", message);

}

Node* message_node = StringConstant(&(buffer[0]));

#ifdef DEBUG

// Only print the extra nodes in debug builds.

MaybePrintNodeWithName(this, extra_node1, extra_node1_name);

MaybePrintNodeWithName(this, extra_node2, extra_node2_name);

MaybePrintNodeWithName(this, extra_node3, extra_node3_name);

MaybePrintNodeWithName(this, extra_node4, extra_node4_name);

MaybePrintNodeWithName(this, extra_node5, extra_node5_name);

#endif

DebugAbort(message_node);

Unreachable();

BIND(&ok);

Comment("] Assert");

}

void CodeStubAssembler::Check(const NodeGenerator& condition_body,

const char* message, const char* file, int line,

Node* extra_node1, const char* extra_node1_name,

Node* extra_node2, const char* extra_node2_name,

Node* extra_node3, const char* extra_node3_name,

Node* extra_node4, const char* extra_node4_name,

Node* extra_node5, const char* extra_node5_name) {

BranchGenerator branch = [=](Label* ok, Label* not_ok) {

Node* condition = condition_body();

DCHECK_NOT_NULL(condition);

Branch(condition, ok, not_ok);

};

Check(branch, message, file, line, extra_node1, extra_node1_name, extra_node2,

extra_node2_name, extra_node3, extra_node3_name, extra_node4,

extra_node4_name, extra_node5, extra_node5_name);

}

void CodeStubAssembler::FastCheck(TNode<BoolT> condition) {

Label ok(this);

GotoIf(condition, &ok);

DebugBreak();

Goto(&ok);

BIND(&ok);

}

Node* CodeStubAssembler::SelectImpl(TNode<BoolT> condition,

const NodeGenerator& true_body,

const NodeGenerator& false_body,

MachineRepresentation rep) {

VARIABLE(value, rep);

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

Branch(condition, &vtrue, &vfalse);

BIND(&vtrue);

{

value.Bind(true_body());

Goto(&end);

}

BIND(&vfalse);

{

value.Bind(false_body());

Goto(&end);

}

BIND(&end);

return value.value();

}

TNode<Int32T> CodeStubAssembler::SelectInt32Constant(

SloppyTNode<BoolT> condition, int true_value, int false_value) {

return SelectConstant<Int32T>(condition, Int32Constant(true_value),

Int32Constant(false_value));

}

TNode<IntPtrT> CodeStubAssembler::SelectIntPtrConstant(

SloppyTNode<BoolT> condition, int true_value, int false_value) {

return SelectConstant<IntPtrT>(condition, IntPtrConstant(true_value),

IntPtrConstant(false_value));

}

TNode<Oddball> CodeStubAssembler::SelectBooleanConstant(

SloppyTNode<BoolT> condition) {

return SelectConstant<Oddball>(condition, TrueConstant(), FalseConstant());

}

TNode<Smi> CodeStubAssembler::SelectSmiConstant(SloppyTNode<BoolT> condition,

Smi* true_value,

Smi* false_value) {

return SelectConstant<Smi>(condition, SmiConstant(true_value),

SmiConstant(false_value));

}

TNode<Object> CodeStubAssembler::NoContextConstant() {

return SmiConstant(Context::kNoContext);

}

#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name) \

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

*std::declval<Heap>().rootAccessorName())>::type> \

CodeStubAssembler::name##Constant() { \

return UncheckedCast<std::remove_reference<decltype( \

*std::declval<Heap>().rootAccessorName())>::type>( \

LoadRoot(Heap::k##rootIndexName##RootIndex)); \

}

HEAP_MUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR);

#undef HEAP_CONSTANT_ACCESSOR

#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name) \

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

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

CodeStubAssembler::name##Constant() { \

return UncheckedCast<std::remove_reference<decltype( \

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

LoadRoot(Heap::k##rootIndexName##RootIndex)); \

}

HEAP_IMMUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR);

#undef HEAP_CONSTANT_ACCESSOR

#define HEAP_CONSTANT_TEST(rootIndexName, rootAccessorName, name) \

compiler::TNode<BoolT> CodeStubAssembler::Is##name( \

SloppyTNode<Object> value) { \

return WordEqual(value, name##Constant()); \

} \

compiler::TNode<BoolT> CodeStubAssembler::IsNot##name( \

SloppyTNode<Object> value) { \

return WordNotEqual(value, name##Constant()); \

}

HEAP_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_TEST);

#undef HEAP_CONSTANT_TEST

Node* CodeStubAssembler::IntPtrOrSmiConstant(int value, ParameterMode mode) {

if (mode == SMI_PARAMETERS) {

return SmiConstant(value);

} else {

DCHECK_EQ(INTPTR_PARAMETERS, mode);

return IntPtrConstant(value);

}

}

bool CodeStubAssembler::IsIntPtrOrSmiConstantZero(Node* test,

ParameterMode mode) {

int32_t constant_test;

Smi* smi_test;

if (mode == INTPTR_PARAMETERS) {

if (ToInt32Constant(test, constant_test) && constant_test == 0) {

return true;

}

} else {

DCHECK_EQ(mode, SMI_PARAMETERS);

if (ToSmiConstant(test, smi_test) && smi_test->value() == 0) {

return true;

}

}

return false;

}

bool CodeStubAssembler::TryGetIntPtrOrSmiConstantValue(Node* maybe_constant,

int* value,

ParameterMode mode) {

int32_t int32_constant;

if (mode == INTPTR_PARAMETERS) {

if (ToInt32Constant(maybe_constant, int32_constant)) {

*value = int32_constant;

return true;

}

} else {

DCHECK_EQ(mode, SMI_PARAMETERS);

Smi* smi_constant;

if (ToSmiConstant(maybe_constant, smi_constant)) {

*value = Smi::ToInt(smi_constant);

return true;

}

}

return false;

}

TNode<IntPtrT> CodeStubAssembler::IntPtrRoundUpToPowerOfTwo32(

TNode<IntPtrT> value) {

Comment("IntPtrRoundUpToPowerOfTwo32");

CSA_ASSERT(this, UintPtrLessThanOrEqual(value, IntPtrConstant(0x80000000u)));

value = Signed(IntPtrSub(value, IntPtrConstant(1)));

for (int i = 1; i <= 16; i *= 2) {

value = Signed(WordOr(value, WordShr(value, IntPtrConstant(i))));

}

return Signed(IntPtrAdd(value, IntPtrConstant(1)));

}

Node* CodeStubAssembler::MatchesParameterMode(Node* value, ParameterMode mode) {

if (mode == SMI_PARAMETERS) {

return TaggedIsSmi(value);

} else {

return Int32Constant(1);

}

}

TNode<BoolT> CodeStubAssembler::WordIsPowerOfTwo(SloppyTNode<IntPtrT> value) {

// value && !(value & (value - 1))

return WordEqual(

Select<IntPtrT>(

WordEqual(value, IntPtrConstant(0)),

[=] { return IntPtrConstant(1); },

[=] { return WordAnd(value, IntPtrSub(value, IntPtrConstant(1))); }),

IntPtrConstant(0));

}

TNode<Float64T> CodeStubAssembler::Float64Round(SloppyTNode<Float64T> x) {

Node* one = Float64Constant(1.0);

Node* one_half = Float64Constant(0.5);

Label return_x(this);

// Round up {x} towards Infinity.

VARIABLE(var_x, MachineRepresentation::kFloat64, Float64Ceil(x));

GotoIf(Float64LessThanOrEqual(Float64Sub(var_x.value(), one_half), x),

&return_x);

var_x.Bind(Float64Sub(var_x.value(), one));

Goto(&return_x);

BIND(&return_x);

return TNode<Float64T>::UncheckedCast(var_x.value());

}

TNode<Float64T> CodeStubAssembler::Float64Ceil(SloppyTNode<Float64T> x) {

if (IsFloat64RoundUpSupported()) {

return Float64RoundUp(x);

}

Node* one = Float64Constant(1.0);

Node* zero = Float64Constant(0.0);

Node* two_52 = Float64Constant(4503599627370496.0E0);

Node* minus_two_52 = Float64Constant(-4503599627370496.0E0);

VARIABLE(var_x, MachineRepresentation::kFloat64, x);

Label return_x(this), return_minus_x(this);

// Check if {x} is greater than zero.

Label if_xgreaterthanzero(this), if_xnotgreaterthanzero(this);

Branch(Float64GreaterThan(x, zero), &if_xgreaterthanzero,

&if_xnotgreaterthanzero);

BIND(&if_xgreaterthanzero);

{

// Just return {x} unless it's in the range ]0,2^52[.

GotoIf(Float64GreaterThanOrEqual(x, two_52), &return_x);

// Round positive {x} towards Infinity.

var_x.Bind(Float64Sub(Float64Add(two_52, x), two_52));

GotoIfNot(Float64LessThan(var_x.value(), x), &return_x);

var_x.Bind(Float64Add(var_x.value(), one));

Goto(&return_x);

}

BIND(&if_xnotgreaterthanzero);

{

// Just return {x} unless it's in the range ]-2^52,0[

GotoIf(Float64LessThanOrEqual(x, minus_two_52), &return_x);

GotoIfNot(Float64LessThan(x, zero), &return_x);

// Round negated {x} towards Infinity and return the result negated.

Node* minus_x = Float64Neg(x);

var_x.Bind(Float64Sub(Float64Add(two_52, minus_x), two_52));

GotoIfNot(Float64GreaterThan(var_x.value(), minus_x), &return_minus_x);

var_x.Bind(Float64Sub(var_x.value(), one));

Goto(&return_minus_x);

}

BIND(&return_minus_x);

var_x.Bind(Float64Neg(var_x.value()));

Goto(&return_x);

BIND(&return_x);

return TNode<Float64T>::UncheckedCast(var_x.value());

}

TNode<Float64T> CodeStubAssembler::Float64Floor(SloppyTNode<Float64T> x) {

if (IsFloat64RoundDownSupported()) {

return Float64RoundDown(x);

}

Node* one = Float64Constant(1.0);

Node* zero = Float64Constant(0.0);

Node* two_52 = Float64Constant(4503599627370496.0E0);

Node* minus_two_52 = Float64Constant(-4503599627370496.0E0);

VARIABLE(var_x, MachineRepresentation::kFloat64, x);

Label return_x(this), return_minus_x(this);

// Check if {x} is greater than zero.

Label if_xgreaterthanzero(this), if_xnotgreaterthanzero(this);

Branch(Float64GreaterThan(x, zero), &if_xgreaterthanzero,

&if_xnotgreaterthanzero);

BIND(&if_xgreaterthanzero);

{

// Just return {x} unless it's in the range ]0,2^52[.

GotoIf(Float64GreaterThanOrEqual(x, two_52), &return_x);

// Round positive {x} towards -Infinity.

var_x.Bind(Float64Sub(Float64Add(two_52, x), two_52));

GotoIfNot(Float64GreaterThan(var_x.value(), x), &return_x);

var_x.Bind(Float64Sub(var_x.value(), one));

Goto(&return_x);

}

BIND(&if_xnotgreaterthanzero);

{

// Just return {x} unless it's in the range ]-2^52,0[

GotoIf(Float64LessThanOrEqual(x, minus_two_52), &return_x);

GotoIfNot(Float64LessThan(x, zero), &return_x);

// Round negated {x} towards -Infinity and return the result negated.

Node* minus_x = Float64Neg(x);

var_x.Bind(Float64Sub(Float64Add(two_52, minus_x), two_52));

GotoIfNot(Float64LessThan(var_x.value(), minus_x), &return_minus_x);

var_x.Bind(Float64Add(var_x.value(), one));

Goto(&return_minus_x);

}

BIND(&return_minus_x);

var_x.Bind(Float64Neg(var_x.value()));

Goto(&return_x);

BIND(&return_x);

return TNode<Float64T>::UncheckedCast(var_x.value());

}

TNode<Float64T> CodeStubAssembler::Float64RoundToEven(SloppyTNode<Float64T> x) {

if (IsFloat64RoundTiesEvenSupported()) {

return Float64RoundTiesEven(x);

}

// See ES#sec-touint8clamp for details.

Node* f = Float64Floor(x);

Node* f_and_half = Float64Add(f, Float64Constant(0.5));

VARIABLE(var_result, MachineRepresentation::kFloat64);

Label return_f(this), return_f_plus_one(this), done(this);

GotoIf(Float64LessThan(f_and_half, x), &return_f_plus_one);

GotoIf(Float64LessThan(x, f_and_half), &return_f);

{

Node* f_mod_2 = Float64Mod(f, Float64Constant(2.0));

Branch(Float64Equal(f_mod_2, Float64Constant(0.0)), &return_f,

&return_f_plus_one);

}

BIND(&return_f);

var_result.Bind(f);

Goto(&done);

BIND(&return_f_plus_one);

var_result.Bind(Float64Add(f, Float64Constant(1.0)));

Goto(&done);

BIND(&done);

return TNode<Float64T>::UncheckedCast(var_result.value());

}

TNode<Float64T> CodeStubAssembler::Float64Trunc(SloppyTNode<Float64T> x) {

if (IsFloat64RoundTruncateSupported()) {

return Float64RoundTruncate(x);

}

Node* one = Float64Constant(1.0);

Node* zero = Float64Constant(0.0);

Node* two_52 = Float64Constant(4503599627370496.0E0);

Node* minus_two_52 = Float64Constant(-4503599627370496.0E0);

VARIABLE(var_x, MachineRepresentation::kFloat64, x);

Label return_x(this), return_minus_x(this);

// Check if {x} is greater than 0.

Label if_xgreaterthanzero(this), if_xnotgreaterthanzero(this);

Branch(Float64GreaterThan(x, zero), &if_xgreaterthanzero,

&if_xnotgreaterthanzero);

BIND(&if_xgreaterthanzero);

{

if (IsFloat64RoundDownSupported()) {

var_x.Bind(Float64RoundDown(x));

} else {

// Just return {x} unless it's in the range ]0,2^52[.

GotoIf(Float64GreaterThanOrEqual(x, two_52), &return_x);

// Round positive {x} towards -Infinity.

var_x.Bind(Float64Sub(Float64Add(two_52, x), two_52));

GotoIfNot(Float64GreaterThan(var_x.value(), x), &return_x);

var_x.Bind(Float64Sub(var_x.value(), one));

}

Goto(&return_x);

}

BIND(&if_xnotgreaterthanzero);

{

if (IsFloat64RoundUpSupported()) {

var_x.Bind(Float64RoundUp(x));

Goto(&return_x);

} else {

// Just return {x} unless its in the range ]-2^52,0[.

GotoIf(Float64LessThanOrEqual(x, minus_two_52), &return_x);

GotoIfNot(Float64LessThan(x, zero), &return_x);

// Round negated {x} towards -Infinity and return result negated.

Node* minus_x = Float64Neg(x);

var_x.Bind(Float64Sub(Float64Add(two_52, minus_x), two_52));

GotoIfNot(Float64GreaterThan(var_x.value(), minus_x), &return_minus_x);

var_x.Bind(Float64Sub(var_x.value(), one));

Goto(&return_minus_x);

}

}

BIND(&return_minus_x);

var_x.Bind(Float64Neg(var_x.value()));

Goto(&return_x);

BIND(&return_x);

return TNode<Float64T>::UncheckedCast(var_x.value());

}

TNode<BoolT> CodeStubAssembler::IsValidSmi(TNode<Smi> smi) {

if (SmiValuesAre31Bits() && kPointerSize == kInt64Size) {

// Check that the Smi value is properly sign-extended.

TNode<IntPtrT> value = Signed(BitcastTaggedToWord(smi));

return WordEqual(value, ChangeInt32ToIntPtr(TruncateIntPtrToInt32(value)));

}

return Int32TrueConstant();

}

Node* CodeStubAssembler::SmiShiftBitsConstant() {

return IntPtrConstant(kSmiShiftSize + kSmiTagSize);

}

TNode<Smi> CodeStubAssembler::SmiFromInt32(SloppyTNode<Int32T> value) {

TNode<IntPtrT> value_intptr = ChangeInt32ToIntPtr(value);

TNode<Smi> smi =

BitcastWordToTaggedSigned(WordShl(value_intptr, SmiShiftBitsConstant()));

#if V8_COMPRESS_POINTERS

CSA_ASSERT(this, IsValidSmi(smi));

#endif

return smi;

}

TNode<BoolT> CodeStubAssembler::IsValidPositiveSmi(TNode<IntPtrT> value) {

intptr_t constant_value;

if (ToIntPtrConstant(value, constant_value)) {

return (static_cast<uintptr_t>(constant_value) <=

static_cast<uintptr_t>(Smi::kMaxValue))

? Int32TrueConstant()

: Int32FalseConstant();

}

return UintPtrLessThanOrEqual(value, IntPtrConstant(Smi::kMaxValue));

}

TNode<Smi> CodeStubAssembler::SmiTag(SloppyTNode<IntPtrT> value) {

int32_t constant_value;

if (ToInt32Constant(value, constant_value) && Smi::IsValid(constant_value)) {

return SmiConstant(constant_value);

}

TNode<Smi> smi =

BitcastWordToTaggedSigned(WordShl(value, SmiShiftBitsConstant()));

#if V8_COMPRESS_POINTERS

CSA_ASSERT(this, IsValidSmi(smi));

#endif

return smi;

}

TNode<IntPtrT> CodeStubAssembler::SmiUntag(SloppyTNode<Smi> value) {

#if V8_COMPRESS_POINTERS

CSA_ASSERT(this, IsValidSmi(value));

#endif

intptr_t constant_value;

if (ToIntPtrConstant(value, constant_value)) {

return IntPtrConstant(constant_value >> (kSmiShiftSize + kSmiTagSize));

}

return Signed(WordSar(BitcastTaggedToWord(value), SmiShiftBitsConstant()));

}

TNode<Int32T> CodeStubAssembler::SmiToInt32(SloppyTNode<Smi> value) {

TNode<IntPtrT> result = SmiUntag(value);

return TruncateIntPtrToInt32(result);

}

TNode<Float64T> CodeStubAssembler::SmiToFloat64(SloppyTNode<Smi> value) {

return ChangeInt32ToFloat64(SmiToInt32(value));

}

TNode<Smi> CodeStubAssembler::SmiMax(TNode<Smi> a, TNode<Smi> b) {

return SelectConstant<Smi>(SmiLessThan(a, b), b, a);

}

TNode<Smi> CodeStubAssembler::SmiMin(TNode<Smi> a, TNode<Smi> b) {

return SelectConstant<Smi>(SmiLessThan(a, b), a, b);

}

TNode<Smi> CodeStubAssembler::TrySmiAdd(TNode<Smi> lhs, TNode<Smi> rhs,

Label* if_overflow) {

if (SmiValuesAre32Bits()) {

TNode<PairT<IntPtrT, BoolT>> pair = IntPtrAddWithOverflow(

BitcastTaggedToWord(lhs), BitcastTaggedToWord(rhs));

TNode<BoolT> overflow = Projection<1>(pair);

GotoIf(overflow, if_overflow);

TNode<IntPtrT> result = Projection<0>(pair);

return BitcastWordToTaggedSigned(result);

} else {

DCHECK(SmiValuesAre31Bits());

TNode<PairT<Int32T, BoolT>> pair =

Int32AddWithOverflow(TruncateIntPtrToInt32(BitcastTaggedToWord(lhs)),

TruncateIntPtrToInt32(BitcastTaggedToWord(rhs)));

TNode<BoolT> overflow = Projection<1>(pair);

GotoIf(overflow, if_overflow);

TNode<Int32T> result = Projection<0>(pair);

return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(result));

}

}

TNode<Smi> CodeStubAssembler::TrySmiSub(TNode<Smi> lhs, TNode<Smi> rhs,

Label* if_overflow) {

if (SmiValuesAre32Bits()) {

TNode<PairT<IntPtrT, BoolT>> pair = IntPtrSubWithOverflow(

BitcastTaggedToWord(lhs), BitcastTaggedToWord(rhs));

TNode<BoolT> overflow = Projection<1>(pair);

GotoIf(overflow, if_overflow);

TNode<IntPtrT> result = Projection<0>(pair);

return BitcastWordToTaggedSigned(result);

} else {

DCHECK(SmiValuesAre31Bits());

TNode<PairT<Int32T, BoolT>> pair =

Int32SubWithOverflow(TruncateIntPtrToInt32(BitcastTaggedToWord(lhs)),

TruncateIntPtrToInt32(BitcastTaggedToWord(rhs)));

TNode<BoolT> overflow = Projection<1>(pair);

GotoIf(overflow, if_overflow);

TNode<Int32T> result = Projection<0>(pair);

return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(result));

}

}

TNode<Object> CodeStubAssembler::NumberMax(SloppyTNode<Object> a,

SloppyTNode<Object> b) {

// TODO(danno): This could be optimized by specifically handling smi cases.

VARIABLE(result, MachineRepresentation::kTagged);

Label done(this), greater_than_equal_a(this), greater_than_equal_b(this);

GotoIfNumberGreaterThanOrEqual(a, b, &greater_than_equal_a);

GotoIfNumberGreaterThanOrEqual(b, a, &greater_than_equal_b);

result.Bind(NanConstant());

Goto(&done);

BIND(&greater_than_equal_a);

result.Bind(a);

Goto(&done);

BIND(&greater_than_equal_b);

result.Bind(b);

Goto(&done);

BIND(&done);

return TNode<Object>::UncheckedCast(result.value());

}

TNode<Object> CodeStubAssembler::NumberMin(SloppyTNode<Object> a,

SloppyTNode<Object> b) {

// TODO(danno): This could be optimized by specifically handling smi cases.

VARIABLE(result, MachineRepresentation::kTagged);

Label done(this), greater_than_equal_a(this), greater_than_equal_b(this);

GotoIfNumberGreaterThanOrEqual(a, b, &greater_than_equal_a);

GotoIfNumberGreaterThanOrEqual(b, a, &greater_than_equal_b);

result.Bind(NanConstant());

Goto(&done);

BIND(&greater_than_equal_a);

result.Bind(b);

Goto(&done);

BIND(&greater_than_equal_b);

result.Bind(a);

Goto(&done);

BIND(&done);

return TNode<Object>::UncheckedCast(result.value());

}

TNode<IntPtrT> CodeStubAssembler::ConvertToRelativeIndex(

TNode<Context> context, TNode<Object> index, TNode<IntPtrT> length) {

TVARIABLE(IntPtrT, result);

TNode<Number> const index_int =

ToInteger_Inline(context, index, CodeStubAssembler::kTruncateMinusZero);

TNode<IntPtrT> zero = IntPtrConstant(0);

Label done(this);

Label if_issmi(this), if_isheapnumber(this, Label::kDeferred);

Branch(TaggedIsSmi(index_int), &if_issmi, &if_isheapnumber);

BIND(&if_issmi);

{

TNode<Smi> const index_smi = CAST(index_int);

result = Select<IntPtrT>(

IntPtrLessThan(SmiUntag(index_smi), zero),

[=] { return IntPtrMax(IntPtrAdd(length, SmiUntag(index_smi)), zero); },

[=] { return IntPtrMin(SmiUntag(index_smi), length); });

Goto(&done);

}

BIND(&if_isheapnumber);

{

// If {index} is a heap number, it is definitely out of bounds. If it is

// negative, {index} = max({length} + {index}),0) = 0'. If it is positive,

// set {index} to {length}.

TNode<HeapNumber> const index_hn = CAST(index_int);

TNode<Float64T> const float_zero = Float64Constant(0.);

TNode<Float64T> const index_float = LoadHeapNumberValue(index_hn);

result = SelectConstant<IntPtrT>(Float64LessThan(index_float, float_zero),

zero, length);

Goto(&done);

}

BIND(&done);

return result.value();

}

TNode<Number> CodeStubAssembler::SmiMod(TNode<Smi> a, TNode<Smi> b) {

TVARIABLE(Number, var_result);

Label return_result(this, &var_result),

return_minuszero(this, Label::kDeferred),

return_nan(this, Label::kDeferred);

// Untag {a} and {b}.

TNode<Int32T> int_a = SmiToInt32(a);

TNode<Int32T> int_b = SmiToInt32(b);

// Return NaN if {b} is zero.

GotoIf(Word32Equal(int_b, Int32Constant(0)), &return_nan);

// Check if {a} is non-negative.

Label if_aisnotnegative(this), if_aisnegative(this, Label::kDeferred);

Branch(Int32LessThanOrEqual(Int32Constant(0), int_a), &if_aisnotnegative,

&if_aisnegative);

BIND(&if_aisnotnegative);

{

// Fast case, don't need to check any other edge cases.

TNode<Int32T> r = Int32Mod(int_a, int_b);

var_result = SmiFromInt32(r);

Goto(&return_result);

}

BIND(&if_aisnegative);

{

if (SmiValuesAre32Bits()) {

// Check if {a} is kMinInt and {b} is -1 (only relevant if the

// kMinInt is actually representable as a Smi).

Label join(this);

GotoIfNot(Word32Equal(int_a, Int32Constant(kMinInt)), &join);

GotoIf(Word32Equal(int_b, Int32Constant(-1)), &return_minuszero);

Goto(&join);

BIND(&join);

}

// Perform the integer modulus operation.

TNode<Int32T> r = Int32Mod(int_a, int_b);

// Check if {r} is zero, and if so return -0, because we have to

// take the sign of the left hand side {a}, which is negative.

GotoIf(Word32Equal(r, Int32Constant(0)), &return_minuszero);

// The remainder {r} can be outside the valid Smi range on 32bit

// architectures, so we cannot just say SmiFromInt32(r) here.

var_result = ChangeInt32ToTagged(r);

Goto(&return_result);

}

BIND(&return_minuszero);

var_result = MinusZeroConstant();

Goto(&return_result);

BIND(&return_nan);

var_result = NanConstant();

Goto(&return_result);

BIND(&return_result);

return var_result.value();

}

TNode<Number> CodeStubAssembler::SmiMul(TNode<Smi> a, TNode<Smi> b) {

TVARIABLE(Number, var_result);

VARIABLE(var_lhs_float64, MachineRepresentation::kFloat64);

VARIABLE(var_rhs_float64, MachineRepresentation::kFloat64);

Label return_result(this, &var_result);

// Both {a} and {b} are Smis. Convert them to integers and multiply.

Node* lhs32 = SmiToInt32(a);

Node* rhs32 = SmiToInt32(b);

Node* pair = Int32MulWithOverflow(lhs32, rhs32);

Node* overflow = Projection(1, pair);

// Check if the multiplication overflowed.

Label if_overflow(this, Label::kDeferred), if_notoverflow(this);

Branch(overflow, &if_overflow, &if_notoverflow);

BIND(&if_notoverflow);

{

// If the answer is zero, we may need to return -0.0, depending on the

// input.

Label answer_zero(this), answer_not_zero(this);

Node* answer = Projection(0, pair);

Node* zero = Int32Constant(0);

Branch(Word32Equal(answer, zero), &answer_zero, &answer_not_zero);

BIND(&answer_not_zero);

{

var_result = ChangeInt32ToTagged(answer);

Goto(&return_result);

}

BIND(&answer_zero);

{

Node* or_result = Word32Or(lhs32, rhs32);

Label if_should_be_negative_zero(this), if_should_be_zero(this);

Branch(Int32LessThan(or_result, zero), &if_should_be_negative_zero,

&if_should_be_zero);

BIND(&if_should_be_negative_zero);

{

var_result = MinusZeroConstant();

Goto(&return_result);

}

BIND(&if_should_be_zero);

{

var_result = SmiConstant(0);

Goto(&return_result);

}

}

}

BIND(&if_overflow);

{

var_lhs_float64.Bind(SmiToFloat64(a));

var_rhs_float64.Bind(SmiToFloat64(b));

Node* value = Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());

var_result = AllocateHeapNumberWithValue(value);

Goto(&return_result);

}

BIND(&return_result);

return var_result.value();

}

TNode<Smi> CodeStubAssembler::TrySmiDiv(TNode<Smi> dividend, TNode<Smi> divisor,

Label* bailout) {

// Both {a} and {b} are Smis. Bailout to floating point division if {divisor}

// is zero.

GotoIf(WordEqual(divisor, SmiConstant(0)), bailout);

// Do floating point division if {dividend} is zero and {divisor} is

// negative.

Label dividend_is_zero(this), dividend_is_not_zero(this);

Branch(WordEqual(dividend, SmiConstant(0)), &dividend_is_zero,

&dividend_is_not_zero);

BIND(&dividend_is_zero);

{

GotoIf(SmiLessThan(divisor, SmiConstant(0)), bailout);

Goto(&dividend_is_not_zero);

}

BIND(&dividend_is_not_zero);

TNode<Int32T> untagged_divisor = SmiToInt32(divisor);

TNode<Int32T> untagged_dividend = SmiToInt32(dividend);

// Do floating point division if {dividend} is kMinInt (or kMinInt - 1

// if the Smi size is 31) and {divisor} is -1.

Label divisor_is_minus_one(this), divisor_is_not_minus_one(this);

Branch(Word32Equal(untagged_divisor, Int32Constant(-1)),

&divisor_is_minus_one, &divisor_is_not_minus_one);

BIND(&divisor_is_minus_one);

{

GotoIf(Word32Equal(

untagged_dividend,

Int32Constant(kSmiValueSize == 32 ? kMinInt : (kMinInt >> 1))),

bailout);

Goto(&divisor_is_not_minus_one);

}

BIND(&divisor_is_not_minus_one);

TNode<Int32T> untagged_result = Int32Div(untagged_dividend, untagged_divisor);

TNode<Int32T> truncated = Signed(Int32Mul(untagged_result, untagged_divisor));

// Do floating point division if the remainder is not 0.

GotoIf(Word32NotEqual(untagged_dividend, truncated), bailout);

return SmiFromInt32(untagged_result);

}

TNode<Int32T> CodeStubAssembler::TruncateIntPtrToInt32(

SloppyTNode<IntPtrT> value) {

if (Is64()) {

return TruncateInt64ToInt32(ReinterpretCast<Int64T>(value));

}

return ReinterpretCast<Int32T>(value);

}

TNode<BoolT> CodeStubAssembler::TaggedIsSmi(SloppyTNode<Object> a) {

return WordEqual(WordAnd(BitcastTaggedToWord(a), IntPtrConstant(kSmiTagMask)),

IntPtrConstant(0));

}

TNode<BoolT> CodeStubAssembler::TaggedIsSmi(TNode<MaybeObject> a) {

return WordEqual(

WordAnd(BitcastMaybeObjectToWord(a), IntPtrConstant(kSmiTagMask)),

IntPtrConstant(0));

}

TNode<BoolT> CodeStubAssembler::TaggedIsNotSmi(SloppyTNode<Object> a) {

return WordNotEqual(

WordAnd(BitcastTaggedToWord(a), IntPtrConstant(kSmiTagMask)),

IntPtrConstant(0));

}

TNode<BoolT> CodeStubAssembler::TaggedIsPositiveSmi(SloppyTNode<Object> a) {

return WordEqual(WordAnd(BitcastTaggedToWord(a),

IntPtrConstant(kSmiTagMask | kSmiSignMask)),

IntPtrConstant(0));

}

TNode<BoolT> CodeStubAssembler::WordIsWordAligned(SloppyTNode<WordT> word) {

return WordEqual(IntPtrConstant(0),

WordAnd(word, IntPtrConstant(kPointerSize - 1)));

}

#if DEBUG

void CodeStubAssembler::Bind(Label* label, AssemblerDebugInfo debug_info) {

CodeAssembler::Bind(label, debug_info);

}

#else

void CodeStubAssembler::Bind(Label* label) { CodeAssembler::Bind(label); }

#endif // DEBUG

TNode<Float64T> CodeStubAssembler::LoadDoubleWithHoleCheck(

TNode<FixedDoubleArray> array, TNode<Smi> index, Label* if_hole) {

return LoadFixedDoubleArrayElement(array, index, MachineType::Float64(), 0,

SMI_PARAMETERS, if_hole);

}

void CodeStubAssembler::BranchIfPrototypesHaveNoElements(

Node* receiver_map, Label* definitely_no_elements,

Label* possibly_elements) {

CSA_SLOW_ASSERT(this, IsMap(receiver_map));

VARIABLE(var_map, MachineRepresentation::kTagged, receiver_map);

Label loop_body(this, &var_map);

Node* empty_fixed_array = LoadRoot(Heap::kEmptyFixedArrayRootIndex);

Node* empty_slow_element_dictionary =

LoadRoot(Heap::kEmptySlowElementDictionaryRootIndex);

Goto(&loop_body);

BIND(&loop_body);

{

Node* map = var_map.value();

Node* prototype = LoadMapPrototype(map);

GotoIf(IsNull(prototype), definitely_no_elements);

Node* prototype_map = LoadMap(prototype);

TNode<Int32T> prototype_instance_type = LoadMapInstanceType(prototype_map);

// Pessimistically assume elements if a Proxy, Special API Object,

// or JSValue wrapper is found on the prototype chain. After this

// instance type check, it's not necessary to check for interceptors or

// access checks.

Label if_custom(this, Label::kDeferred), if_notcustom(this);

Branch(IsCustomElementsReceiverInstanceType(prototype_instance_type),

&if_custom, &if_notcustom);

BIND(&if_custom);

{

// For string JSValue wrappers we still support the checks as long

// as they wrap the empty string.

GotoIfNot(InstanceTypeEqual(prototype_instance_type, JS_VALUE_TYPE),

possibly_elements);

Node* prototype_value = LoadJSValueValue(prototype);

Branch(IsEmptyString(prototype_value), &if_notcustom, possibly_elements);

}

BIND(&if_notcustom);

{

Node* prototype_elements = LoadElements(prototype);

var_map.Bind(prototype_map);

GotoIf(WordEqual(prototype_elements, empty_fixed_array), &loop_body);