// 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/codegen/code-stub-assembler.h"

#include "include/v8-internal.h"

#include "src/base/macros.h"

#include "src/codegen/code-factory.h"

#include "src/codegen/tnode.h"

#include "src/common/globals.h"

#include "src/execution/frames-inl.h"

#include "src/execution/frames.h"

#include "src/execution/protectors.h"

#include "src/heap/heap-inl.h" // For MemoryChunk. TODO(jkummerow): Drop.

#include "src/heap/memory-chunk.h"

#include "src/logging/counters.h"

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

#include "src/objects/cell.h"

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

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

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

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

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

#include "src/objects/oddball.h"

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

#include "src/objects/property-cell.h"

#include "src/roots/roots.h"

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

namespace v8 {

namespace internal {

using compiler::Node;

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

: compiler::CodeAssembler(state),

TorqueGeneratedExportedMacrosAssembler(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,

std::initializer_list<ExtraNode> extra_nodes) {

#if defined(DEBUG)

if (FLAG_debug_code) {

Check(branch, message, file, line, extra_nodes);

}

#endif

}

void CodeStubAssembler::Assert(const NodeGenerator<BoolT>& condition_body,

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

std::initializer_list<ExtraNode> extra_nodes) {

#if defined(DEBUG)

if (FLAG_debug_code) {

Check(condition_body, message, file, line, extra_nodes);

}

#endif

}

void CodeStubAssembler::Assert(SloppyTNode<Word32T> condition_node,

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

std::initializer_list<ExtraNode> extra_nodes) {

#if defined(DEBUG)

if (FLAG_debug_code) {

Check(condition_node, message, file, line, extra_nodes);

}

#endif

}

void CodeStubAssembler::Check(const BranchGenerator& branch,

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

std::initializer_list<ExtraNode> extra_nodes) {

Label ok(this);

Label not_ok(this, Label::kDeferred);

if (message != nullptr && FLAG_code_comments) {

Comment("[ Assert: ", message);

} else {

Comment("[ Assert");

}

branch(&ok, &not_ok);

BIND(&not_ok);

FailAssert(message, file, line, extra_nodes);

BIND(&ok);

Comment("] Assert");

}

void CodeStubAssembler::Check(const NodeGenerator<BoolT>& condition_body,

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

std::initializer_list<ExtraNode> extra_nodes) {

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

TNode<BoolT> condition = condition_body();

Branch(condition, ok, not_ok);

};

Check(branch, message, file, line, extra_nodes);

}

void CodeStubAssembler::Check(SloppyTNode<Word32T> condition_node,

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

std::initializer_list<ExtraNode> extra_nodes) {

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

Branch(condition_node, ok, not_ok);

};

Check(branch, message, file, line, extra_nodes);

}

void CodeStubAssembler::IncrementCallCount(

TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot_id) {

Comment("increment call count");

TNode<Smi> call_count =

CAST(LoadFeedbackVectorSlot(feedback_vector, slot_id, kTaggedSize));

// The lowest {FeedbackNexus::CallCountField::kShift} bits of the call

// count are used as flags. To increment the call count by 1 we hence

// have to increment by 1 << {FeedbackNexus::CallCountField::kShift}.

TNode<Smi> new_count = SmiAdd(

call_count, SmiConstant(1 << FeedbackNexus::CallCountField::kShift));

// Count is Smi, so we don't need a write barrier.

StoreFeedbackVectorSlot(feedback_vector, slot_id, new_count,

SKIP_WRITE_BARRIER, kTaggedSize);

}

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

Label ok(this), not_ok(this, Label::kDeferred);

Branch(condition, &ok, &not_ok);

BIND(&not_ok);

Unreachable();

BIND(&ok);

}

void CodeStubAssembler::FailAssert(

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

std::initializer_list<ExtraNode> extra_nodes) {

DCHECK_NOT_NULL(message);

EmbeddedVector<char, 1024> chars;

if (file != nullptr) {

SNPrintF(chars, "%s [%s:%d]", message, file, line);

message = chars.begin();

}

TNode<String> message_node = StringConstant(message);

#ifdef DEBUG

// Only print the extra nodes in debug builds.

for (auto& node : extra_nodes) {

CallRuntime(Runtime::kPrintWithNameForAssert, SmiConstant(0),

StringConstant(node.second), node.first);

}

#endif

AbortCSAAssert(message_node);

Unreachable();

}

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

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

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

CodeStubAssembler::name##Constant() { \

return UncheckedCast<std::remove_pointer<std::remove_reference<decltype( \

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

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

}

HEAP_MUTABLE_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<ReadOnlyRoots>().rootAccessorName())>::type>::type> \

CodeStubAssembler::name##Constant() { \

return UncheckedCast<std::remove_pointer<std::remove_reference<decltype( \

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

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

}

HEAP_IMMUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR)

#undef HEAP_CONSTANT_ACCESSOR

#define HEAP_CONSTANT_TEST(rootIndexName, rootAccessorName, name) \

TNode<BoolT> CodeStubAssembler::Is##name(SloppyTNode<Object> value) { \

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

} \

TNode<BoolT> CodeStubAssembler::IsNot##name(SloppyTNode<Object> value) { \

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

}

HEAP_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_TEST)

#undef HEAP_CONSTANT_TEST

TNode<BInt> CodeStubAssembler::BIntConstant(int value) {

#if defined(BINT_IS_SMI)

return SmiConstant(value);

#elif defined(BINT_IS_INTPTR)

return IntPtrConstant(value);

#else

#error Unknown architecture.

#endif

}

template <>

TNode<Smi> CodeStubAssembler::IntPtrOrSmiConstant<Smi>(int value) {

return SmiConstant(value);

}

template <>

TNode<IntPtrT> CodeStubAssembler::IntPtrOrSmiConstant<IntPtrT>(int value) {

return IntPtrConstant(value);

}

template <>

TNode<UintPtrT> CodeStubAssembler::IntPtrOrSmiConstant<UintPtrT>(int value) {

return Unsigned(IntPtrConstant(value));

}

template <>

TNode<RawPtrT> CodeStubAssembler::IntPtrOrSmiConstant<RawPtrT>(int value) {

return ReinterpretCast<RawPtrT>(IntPtrConstant(value));

}

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

intptr_t constant;

if (ToIntPtrConstant(value, &constant)) {

return BoolConstant(base::bits::IsPowerOfTwo(constant));

}

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

return IntPtrEqual(

Select<IntPtrT>(

IntPtrEqual(value, IntPtrConstant(0)),

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

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

IntPtrConstant(0));

}

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

TNode<Float64T> one = Float64Constant(1.0);

TNode<Float64T> one_half = Float64Constant(0.5);

Label return_x(this);

// Round up {x} towards Infinity.

TVARIABLE(Float64T, var_x, Float64Ceil(x));

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

&return_x);

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

}

TNode<Float64T> one = Float64Constant(1.0);

TNode<Float64T> zero = Float64Constant(0.0);

TNode<Float64T> two_52 = Float64Constant(4503599627370496.0E0);

TNode<Float64T> minus_two_52 = Float64Constant(-4503599627370496.0E0);

TVARIABLE(Float64T, var_x, 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 = Float64Sub(Float64Add(two_52, x), two_52);

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

var_x = 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.

TNode<Float64T> minus_x = Float64Neg(x);

var_x = Float64Sub(Float64Add(two_52, minus_x), two_52);

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

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

Goto(&return_minus_x);

}

BIND(&return_minus_x);

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

}

TNode<Float64T> one = Float64Constant(1.0);

TNode<Float64T> zero = Float64Constant(0.0);

TNode<Float64T> two_52 = Float64Constant(4503599627370496.0E0);

TNode<Float64T> minus_two_52 = Float64Constant(-4503599627370496.0E0);

TVARIABLE(Float64T, var_x, 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 = Float64Sub(Float64Add(two_52, x), two_52);

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

var_x = 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.

TNode<Float64T> minus_x = Float64Neg(x);

var_x = Float64Sub(Float64Add(two_52, minus_x), two_52);

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

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

Goto(&return_minus_x);

}

BIND(&return_minus_x);

var_x = 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.

TNode<Float64T> f = Float64Floor(x);

TNode<Float64T> f_and_half = Float64Add(f, Float64Constant(0.5));

TVARIABLE(Float64T, var_result);

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

{

TNode<Float64T> 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 = f;

Goto(&done);

BIND(&return_f_plus_one);

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

}

TNode<Float64T> one = Float64Constant(1.0);

TNode<Float64T> zero = Float64Constant(0.0);

TNode<Float64T> two_52 = Float64Constant(4503599627370496.0E0);

TNode<Float64T> minus_two_52 = Float64Constant(-4503599627370496.0E0);

TVARIABLE(Float64T, var_x, 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 = 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 = Float64Sub(Float64Add(two_52, x), two_52);

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

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

}

Goto(&return_x);

}

BIND(&if_xnotgreaterthanzero);

{

if (IsFloat64RoundUpSupported()) {

var_x = 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.

TNode<Float64T> minus_x = Float64Neg(x);

var_x = Float64Sub(Float64Add(two_52, minus_x), two_52);

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

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

Goto(&return_minus_x);

}

}

BIND(&return_minus_x);

var_x = 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 (SmiValuesAre32Bits() && kSystemPointerSize == kInt64Size) {

// Check that the Smi value is zero in the lower bits.

TNode<IntPtrT> value = BitcastTaggedToWordForTagAndSmiBits(smi);

return Word32Equal(Int32Constant(0), TruncateIntPtrToInt32(value));

}

return Int32TrueConstant();

}

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

if (COMPRESS_POINTERS_BOOL) {

return WordEqual(

BitcastTaggedToWordForTagAndSmiBits(smi),

BitcastTaggedToWordForTagAndSmiBits(NormalizeSmiIndex(smi)));

}

return Int32TrueConstant();

}

template <>

TNode<Smi> CodeStubAssembler::TaggedToParameter(TNode<Smi> value) {

return value;

}

template <>

TNode<IntPtrT> CodeStubAssembler::TaggedToParameter(TNode<Smi> value) {

return SmiUntag(value);

}

TNode<IntPtrT> CodeStubAssembler::TaggedIndexToIntPtr(

TNode<TaggedIndex> value) {

return Signed(WordSarShiftOutZeros(BitcastTaggedToWordForTagAndSmiBits(value),

IntPtrConstant(kSmiTagSize)));

}

TNode<TaggedIndex> CodeStubAssembler::IntPtrToTaggedIndex(

TNode<IntPtrT> value) {

return ReinterpretCast<TaggedIndex>(

BitcastWordToTaggedSigned(WordShl(value, IntPtrConstant(kSmiTagSize))));

}

TNode<Smi> CodeStubAssembler::TaggedIndexToSmi(TNode<TaggedIndex> value) {

if (SmiValuesAre32Bits()) {

DCHECK_EQ(kSmiShiftSize, 31);

return BitcastWordToTaggedSigned(

WordShl(BitcastTaggedToWordForTagAndSmiBits(value),

IntPtrConstant(kSmiShiftSize)));

}

DCHECK(SmiValuesAre31Bits());

DCHECK_EQ(kSmiShiftSize, 0);

return ReinterpretCast<Smi>(value);

}

TNode<TaggedIndex> CodeStubAssembler::SmiToTaggedIndex(TNode<Smi> value) {

if (kSystemPointerSize == kInt32Size) {

return ReinterpretCast<TaggedIndex>(value);

}

if (SmiValuesAre32Bits()) {

DCHECK_EQ(kSmiShiftSize, 31);

return ReinterpretCast<TaggedIndex>(BitcastWordToTaggedSigned(

WordSar(BitcastTaggedToWordForTagAndSmiBits(value),

IntPtrConstant(kSmiShiftSize))));

}

DCHECK(SmiValuesAre31Bits());

DCHECK_EQ(kSmiShiftSize, 0);

// Just sign-extend the lower 32 bits.

TNode<Int32T> raw =

TruncateWordToInt32(BitcastTaggedToWordForTagAndSmiBits(value));

return ReinterpretCast<TaggedIndex>(

BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(raw)));

}

TNode<Smi> CodeStubAssembler::NormalizeSmiIndex(TNode<Smi> smi_index) {

if (COMPRESS_POINTERS_BOOL) {

TNode<Int32T> raw =

TruncateWordToInt32(BitcastTaggedToWordForTagAndSmiBits(smi_index));

smi_index = BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(raw));

}

return smi_index;

}

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

if (COMPRESS_POINTERS_BOOL) {

static_assert(!COMPRESS_POINTERS_BOOL || (kSmiShiftSize + kSmiTagSize == 1),

"Use shifting instead of add");

return BitcastWordToTaggedSigned(

ChangeUint32ToWord(Int32Add(value, value)));

}

return SmiTag(ChangeInt32ToIntPtr(value));

}

TNode<Smi> CodeStubAssembler::SmiFromUint32(TNode<Uint32T> value) {

CSA_ASSERT(this, IntPtrLessThan(ChangeUint32ToWord(value),

IntPtrConstant(Smi::kMaxValue)));

return SmiFromInt32(Signed(value));

}

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

}

if (COMPRESS_POINTERS_BOOL) {

return SmiFromInt32(TruncateIntPtrToInt32(value));

}

TNode<Smi> smi =

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

return smi;

}

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

intptr_t constant_value;

if (ToIntPtrConstant(value, &constant_value)) {

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

}

TNode<IntPtrT> raw_bits = BitcastTaggedToWordForTagAndSmiBits(value);

if (COMPRESS_POINTERS_BOOL) {

// Clear the upper half using sign-extension.

raw_bits = ChangeInt32ToIntPtr(TruncateIntPtrToInt32(raw_bits));

}

return Signed(WordSarShiftOutZeros(raw_bits, SmiShiftBitsConstant()));

}

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

if (COMPRESS_POINTERS_BOOL) {

return Signed(Word32SarShiftOutZeros(

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(value)),

SmiShiftBitsConstant32()));

}

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<IntPtrT> CodeStubAssembler::TryIntPtrAdd(TNode<IntPtrT> a,

TNode<IntPtrT> b,

Label* if_overflow) {

TNode<PairT<IntPtrT, BoolT>> pair = IntPtrAddWithOverflow(a, b);

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

GotoIf(overflow, if_overflow);

return Projection<0>(pair);

}

TNode<IntPtrT> CodeStubAssembler::TryIntPtrSub(TNode<IntPtrT> a,

TNode<IntPtrT> b,

Label* if_overflow) {

TNode<PairT<IntPtrT, BoolT>> pair = IntPtrSubWithOverflow(a, b);

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

GotoIf(overflow, if_overflow);

return Projection<0>(pair);

}

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

Label* if_overflow) {

TNode<PairT<Int32T, BoolT>> pair = Int32MulWithOverflow(a, b);

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

GotoIf(overflow, if_overflow);

return Projection<0>(pair);

}

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

Label* if_overflow) {

if (SmiValuesAre32Bits()) {

return BitcastWordToTaggedSigned(

TryIntPtrAdd(BitcastTaggedToWordForTagAndSmiBits(lhs),

BitcastTaggedToWordForTagAndSmiBits(rhs), if_overflow));

} else {

DCHECK(SmiValuesAre31Bits());

TNode<PairT<Int32T, BoolT>> pair = Int32AddWithOverflow(

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(lhs)),

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(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(BitcastTaggedToWordForTagAndSmiBits(lhs),

BitcastTaggedToWordForTagAndSmiBits(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(BitcastTaggedToWordForTagAndSmiBits(lhs)),

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(rhs)));

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

GotoIf(overflow, if_overflow);

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

return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(result));

}

}

TNode<Smi> CodeStubAssembler::TrySmiAbs(TNode<Smi> a, Label* if_overflow) {

if (SmiValuesAre32Bits()) {

TNode<PairT<IntPtrT, BoolT>> pair =

IntPtrAbsWithOverflow(BitcastTaggedToWordForTagAndSmiBits(a));

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

GotoIf(overflow, if_overflow);

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

return BitcastWordToTaggedSigned(result);

} else {

CHECK(SmiValuesAre31Bits());

CHECK(IsInt32AbsWithOverflowSupported());

TNode<PairT<Int32T, BoolT>> pair = Int32AbsWithOverflow(

TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(a)));

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

GotoIf(overflow, if_overflow);

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

return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(result));

}

}

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

SloppyTNode<Number> b) {

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

TVARIABLE(Number, result);

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

Goto(&done);

BIND(&greater_than_equal_a);

result = a;

Goto(&done);

BIND(&greater_than_equal_b);

result = b;

Goto(&done);

BIND(&done);

return result.value();

}

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

SloppyTNode<Number> b) {

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

TVARIABLE(Number, result);

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

Goto(&done);

BIND(&greater_than_equal_a);

result = b;

Goto(&done);

BIND(&greater_than_equal_b);

result = a;

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

TVARIABLE(Float64T, var_lhs_float64);

TVARIABLE(Float64T, var_rhs_float64);

Label return_result(this, &var_result);

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

TNode<Int32T> lhs32 = SmiToInt32(a);

TNode<Int32T> rhs32 = SmiToInt32(b);

auto pair = Int32MulWithOverflow(lhs32, rhs32);

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

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

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

{

TNode<Int32T> 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 = SmiToFloat64(a);

var_rhs_float64 = SmiToFloat64(b);

TNode<Float64T> 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(TaggedEqual(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(TaggedEqual(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 = 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);

}