2015-12-02 12:35:12 +00:00
|
|
|
// Copyright 2015 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/compiler/code-stub-assembler.h"
|
|
|
|
|
|
|
|
#include <ostream>
|
|
|
|
|
|
|
|
#include "src/code-factory.h"
|
|
|
|
#include "src/compiler/graph.h"
|
|
|
|
#include "src/compiler/instruction-selector.h"
|
|
|
|
#include "src/compiler/linkage.h"
|
|
|
|
#include "src/compiler/pipeline.h"
|
|
|
|
#include "src/compiler/raw-machine-assembler.h"
|
|
|
|
#include "src/compiler/schedule.h"
|
|
|
|
#include "src/frames.h"
|
|
|
|
#include "src/interface-descriptors.h"
|
|
|
|
#include "src/interpreter/bytecodes.h"
|
2015-12-03 13:33:14 +00:00
|
|
|
#include "src/machine-type.h"
|
2015-12-02 12:35:12 +00:00
|
|
|
#include "src/macro-assembler.h"
|
|
|
|
#include "src/zone.h"
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
namespace compiler {
|
|
|
|
|
|
|
|
CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
|
|
|
|
const CallInterfaceDescriptor& descriptor,
|
2016-02-10 16:38:49 +00:00
|
|
|
Code::Flags flags, const char* name,
|
|
|
|
size_t result_size)
|
2016-03-17 11:04:51 +00:00
|
|
|
: CodeStubAssembler(
|
|
|
|
isolate, zone,
|
2016-02-10 16:38:49 +00:00
|
|
|
Linkage::GetStubCallDescriptor(
|
|
|
|
isolate, zone, descriptor, descriptor.GetStackParameterCount(),
|
|
|
|
CallDescriptor::kNoFlags, Operator::kNoProperties,
|
2016-03-17 11:04:51 +00:00
|
|
|
MachineType::AnyTagged(), result_size),
|
|
|
|
flags, name) {}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-03-01 22:04:55 +00:00
|
|
|
CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
|
|
|
|
int parameter_count, Code::Flags flags,
|
|
|
|
const char* name)
|
2016-03-17 11:04:51 +00:00
|
|
|
: CodeStubAssembler(isolate, zone, Linkage::GetJSCallDescriptor(
|
|
|
|
zone, false, parameter_count,
|
|
|
|
CallDescriptor::kNoFlags),
|
|
|
|
flags, name) {}
|
|
|
|
|
|
|
|
CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
|
|
|
|
CallDescriptor* call_descriptor,
|
|
|
|
Code::Flags flags, const char* name)
|
2016-03-30 11:56:31 +00:00
|
|
|
: raw_assembler_(new RawMachineAssembler(
|
|
|
|
isolate, new (zone) Graph(zone), call_descriptor,
|
|
|
|
MachineType::PointerRepresentation(),
|
|
|
|
InstructionSelector::SupportedMachineOperatorFlags())),
|
2016-03-01 22:04:55 +00:00
|
|
|
flags_(flags),
|
|
|
|
name_(name),
|
|
|
|
code_generated_(false),
|
|
|
|
variables_(zone) {}
|
|
|
|
|
2015-12-02 12:35:12 +00:00
|
|
|
CodeStubAssembler::~CodeStubAssembler() {}
|
|
|
|
|
2016-02-10 16:38:49 +00:00
|
|
|
void CodeStubAssembler::CallPrologue() {}
|
|
|
|
|
|
|
|
void CodeStubAssembler::CallEpilogue() {}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
|
|
|
Handle<Code> CodeStubAssembler::GenerateCode() {
|
|
|
|
DCHECK(!code_generated_);
|
|
|
|
|
|
|
|
Schedule* schedule = raw_assembler_->Export();
|
|
|
|
Handle<Code> code = Pipeline::GenerateCodeForCodeStub(
|
2016-01-20 15:17:39 +00:00
|
|
|
isolate(), raw_assembler_->call_descriptor(), graph(), schedule, flags_,
|
2015-12-02 12:35:12 +00:00
|
|
|
name_);
|
|
|
|
|
|
|
|
code_generated_ = true;
|
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Int32Constant(int value) {
|
|
|
|
return raw_assembler_->Int32Constant(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::IntPtrConstant(intptr_t value) {
|
|
|
|
return raw_assembler_->IntPtrConstant(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::NumberConstant(double value) {
|
|
|
|
return raw_assembler_->NumberConstant(value);
|
|
|
|
}
|
|
|
|
|
2016-02-25 12:49:02 +00:00
|
|
|
Node* CodeStubAssembler::SmiConstant(Smi* value) {
|
|
|
|
return IntPtrConstant(bit_cast<intptr_t>(value));
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
|
|
|
Node* CodeStubAssembler::HeapConstant(Handle<HeapObject> object) {
|
|
|
|
return raw_assembler_->HeapConstant(object);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::BooleanConstant(bool value) {
|
|
|
|
return raw_assembler_->BooleanConstant(value);
|
|
|
|
}
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
Node* CodeStubAssembler::ExternalConstant(ExternalReference address) {
|
|
|
|
return raw_assembler_->ExternalConstant(address);
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-02-29 12:16:00 +00:00
|
|
|
Node* CodeStubAssembler::Float64Constant(double value) {
|
|
|
|
return raw_assembler_->Float64Constant(value);
|
|
|
|
}
|
|
|
|
|
2016-03-16 09:36:52 +00:00
|
|
|
Node* CodeStubAssembler::BooleanMapConstant() {
|
|
|
|
return HeapConstant(isolate()->factory()->boolean_map());
|
|
|
|
}
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::EmptyStringConstant() {
|
|
|
|
return LoadRoot(Heap::kempty_stringRootIndex);
|
|
|
|
}
|
|
|
|
|
2016-03-02 11:46:57 +00:00
|
|
|
Node* CodeStubAssembler::HeapNumberMapConstant() {
|
|
|
|
return HeapConstant(isolate()->factory()->heap_number_map());
|
|
|
|
}
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::NaNConstant() {
|
|
|
|
return LoadRoot(Heap::kNanValueRootIndex);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::NoContextConstant() {
|
|
|
|
return SmiConstant(Smi::FromInt(0));
|
|
|
|
}
|
|
|
|
|
2016-03-17 11:04:51 +00:00
|
|
|
Node* CodeStubAssembler::NullConstant() {
|
|
|
|
return LoadRoot(Heap::kNullValueRootIndex);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::UndefinedConstant() {
|
|
|
|
return LoadRoot(Heap::kUndefinedValueRootIndex);
|
|
|
|
}
|
|
|
|
|
2015-12-02 12:35:12 +00:00
|
|
|
Node* CodeStubAssembler::Parameter(int value) {
|
|
|
|
return raw_assembler_->Parameter(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeStubAssembler::Return(Node* value) {
|
|
|
|
return raw_assembler_->Return(value);
|
|
|
|
}
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
void CodeStubAssembler::Bind(CodeStubAssembler::Label* label) {
|
|
|
|
return label->Bind();
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::LoadFramePointer() {
|
|
|
|
return raw_assembler_->LoadFramePointer();
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-02-16 07:28:57 +00:00
|
|
|
Node* CodeStubAssembler::LoadParentFramePointer() {
|
|
|
|
return raw_assembler_->LoadParentFramePointer();
|
|
|
|
}
|
|
|
|
|
2016-02-10 16:38:49 +00:00
|
|
|
Node* CodeStubAssembler::LoadStackPointer() {
|
|
|
|
return raw_assembler_->LoadStackPointer();
|
|
|
|
}
|
|
|
|
|
2015-12-02 12:35:12 +00:00
|
|
|
Node* CodeStubAssembler::SmiShiftBitsConstant() {
|
2016-03-01 07:08:20 +00:00
|
|
|
return IntPtrConstant(kSmiShiftSize + kSmiTagSize);
|
2015-12-02 12:35:12 +00:00
|
|
|
}
|
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Node* CodeStubAssembler::Float64Round(Node* x) {
|
|
|
|
Node* one = Float64Constant(1.0);
|
|
|
|
Node* one_half = Float64Constant(0.5);
|
|
|
|
|
|
|
|
Variable var_x(this, MachineRepresentation::kFloat64);
|
|
|
|
Label return_x(this);
|
|
|
|
|
|
|
|
// Round up {x} towards Infinity.
|
|
|
|
var_x.Bind(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 var_x.value();
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Float64Ceil(Node* x) {
|
|
|
|
if (raw_assembler_->machine()->Float64RoundUp().IsSupported()) {
|
|
|
|
return raw_assembler_->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(this, MachineRepresentation::kFloat64);
|
|
|
|
Label return_x(this), return_minus_x(this);
|
|
|
|
var_x.Bind(x);
|
|
|
|
|
|
|
|
// 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));
|
|
|
|
GotoUnless(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);
|
|
|
|
GotoUnless(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));
|
|
|
|
GotoUnless(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 var_x.value();
|
|
|
|
}
|
|
|
|
|
2016-03-28 17:30:05 +00:00
|
|
|
Node* CodeStubAssembler::Float64Floor(Node* x) {
|
|
|
|
if (raw_assembler_->machine()->Float64RoundDown().IsSupported()) {
|
|
|
|
return raw_assembler_->Float64RoundDown(x);
|
|
|
|
}
|
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Node* one = Float64Constant(1.0);
|
|
|
|
Node* zero = Float64Constant(0.0);
|
2016-03-28 17:30:05 +00:00
|
|
|
Node* two_52 = Float64Constant(4503599627370496.0E0);
|
|
|
|
Node* minus_two_52 = Float64Constant(-4503599627370496.0E0);
|
|
|
|
|
|
|
|
Variable var_x(this, MachineRepresentation::kFloat64);
|
2016-03-30 11:56:31 +00:00
|
|
|
Label return_x(this), return_minus_x(this);
|
2016-03-28 17:30:05 +00:00
|
|
|
var_x.Bind(x);
|
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
// Check if {x} is greater than zero.
|
|
|
|
Label if_xgreaterthanzero(this), if_xnotgreaterthanzero(this);
|
|
|
|
Branch(Float64GreaterThan(x, zero), &if_xgreaterthanzero,
|
|
|
|
&if_xnotgreaterthanzero);
|
2016-03-28 17:30:05 +00:00
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Bind(&if_xgreaterthanzero);
|
2016-03-28 17:30:05 +00:00
|
|
|
{
|
2016-03-30 11:56:31 +00:00
|
|
|
// 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));
|
|
|
|
GotoUnless(Float64GreaterThan(var_x.value(), x), &return_x);
|
|
|
|
var_x.Bind(Float64Sub(var_x.value(), one));
|
2016-03-28 17:30:05 +00:00
|
|
|
Goto(&return_x);
|
|
|
|
}
|
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Bind(&if_xnotgreaterthanzero);
|
2016-03-28 17:30:05 +00:00
|
|
|
{
|
2016-03-30 11:56:31 +00:00
|
|
|
// Just return {x} unless it's in the range ]-2^52,0[
|
|
|
|
GotoIf(Float64LessThanOrEqual(x, minus_two_52), &return_x);
|
|
|
|
GotoUnless(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));
|
|
|
|
GotoUnless(Float64LessThan(var_x.value(), minus_x), &return_minus_x);
|
|
|
|
var_x.Bind(Float64Add(var_x.value(), one));
|
|
|
|
Goto(&return_minus_x);
|
|
|
|
}
|
2016-03-28 17:30:05 +00:00
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Bind(&return_minus_x);
|
|
|
|
var_x.Bind(Float64Neg(var_x.value()));
|
|
|
|
Goto(&return_x);
|
2016-03-28 17:30:05 +00:00
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Bind(&return_x);
|
|
|
|
return var_x.value();
|
|
|
|
}
|
2016-03-28 17:30:05 +00:00
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Node* CodeStubAssembler::Float64Trunc(Node* x) {
|
|
|
|
if (raw_assembler_->machine()->Float64RoundTruncate().IsSupported()) {
|
|
|
|
return raw_assembler_->Float64RoundTruncate(x);
|
|
|
|
}
|
2016-03-28 17:30:05 +00:00
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Node* one = Float64Constant(1.0);
|
|
|
|
Node* zero = Float64Constant(0.0);
|
|
|
|
Node* two_52 = Float64Constant(4503599627370496.0E0);
|
|
|
|
Node* minus_two_52 = Float64Constant(-4503599627370496.0E0);
|
2016-03-28 17:30:05 +00:00
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Variable var_x(this, MachineRepresentation::kFloat64);
|
|
|
|
Label return_x(this), return_minus_x(this);
|
|
|
|
var_x.Bind(x);
|
2016-03-28 17:30:05 +00:00
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
// 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 (raw_assembler_->machine()->Float64RoundDown().IsSupported()) {
|
|
|
|
var_x.Bind(raw_assembler_->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));
|
|
|
|
GotoUnless(Float64GreaterThan(var_x.value(), x), &return_x);
|
|
|
|
var_x.Bind(Float64Sub(var_x.value(), one));
|
2016-03-28 17:30:05 +00:00
|
|
|
}
|
2016-03-30 11:56:31 +00:00
|
|
|
Goto(&return_x);
|
2016-03-28 17:30:05 +00:00
|
|
|
}
|
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
Bind(&if_xnotgreaterthanzero);
|
|
|
|
{
|
|
|
|
if (raw_assembler_->machine()->Float64RoundUp().IsSupported()) {
|
|
|
|
var_x.Bind(raw_assembler_->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);
|
|
|
|
GotoUnless(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));
|
|
|
|
GotoUnless(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);
|
|
|
|
|
2016-03-28 17:30:05 +00:00
|
|
|
Bind(&return_x);
|
|
|
|
return var_x.value();
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
|
|
|
Node* CodeStubAssembler::SmiTag(Node* value) {
|
|
|
|
return raw_assembler_->WordShl(value, SmiShiftBitsConstant());
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::SmiUntag(Node* value) {
|
|
|
|
return raw_assembler_->WordSar(value, SmiShiftBitsConstant());
|
|
|
|
}
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::SmiFromWord32(Node* value) {
|
|
|
|
if (raw_assembler_->machine()->Is64()) {
|
|
|
|
value = raw_assembler_->ChangeInt32ToInt64(value);
|
|
|
|
}
|
|
|
|
return raw_assembler_->WordShl(value, SmiShiftBitsConstant());
|
|
|
|
}
|
|
|
|
|
2016-03-24 06:05:03 +00:00
|
|
|
Node* CodeStubAssembler::SmiToWord32(Node* value) {
|
2016-03-01 22:04:55 +00:00
|
|
|
Node* result = raw_assembler_->WordSar(value, SmiShiftBitsConstant());
|
|
|
|
if (raw_assembler_->machine()->Is64()) {
|
|
|
|
result = raw_assembler_->TruncateInt64ToInt32(result);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2016-03-02 11:46:57 +00:00
|
|
|
Node* CodeStubAssembler::SmiToFloat64(Node* value) {
|
|
|
|
return ChangeInt32ToFloat64(SmiUntag(value));
|
|
|
|
}
|
|
|
|
|
2016-02-25 12:49:02 +00:00
|
|
|
Node* CodeStubAssembler::SmiAdd(Node* a, Node* b) { return IntPtrAdd(a, b); }
|
|
|
|
|
2016-03-22 15:42:24 +00:00
|
|
|
Node* CodeStubAssembler::SmiAddWithOverflow(Node* a, Node* b) {
|
|
|
|
return IntPtrAddWithOverflow(a, b);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::SmiSub(Node* a, Node* b) { return IntPtrSub(a, b); }
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::SmiSubWithOverflow(Node* a, Node* b) {
|
|
|
|
return IntPtrSubWithOverflow(a, b);
|
|
|
|
}
|
|
|
|
|
2016-02-29 12:16:00 +00:00
|
|
|
Node* CodeStubAssembler::SmiEqual(Node* a, Node* b) { return WordEqual(a, b); }
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::SmiAboveOrEqual(Node* a, Node* b) {
|
|
|
|
return UintPtrGreaterThanOrEqual(a, b);
|
|
|
|
}
|
|
|
|
|
2016-03-03 16:38:55 +00:00
|
|
|
Node* CodeStubAssembler::SmiLessThan(Node* a, Node* b) {
|
|
|
|
return IntPtrLessThan(a, b);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::SmiLessThanOrEqual(Node* a, Node* b) {
|
|
|
|
return IntPtrLessThanOrEqual(a, b);
|
|
|
|
}
|
|
|
|
|
2016-03-04 09:38:31 +00:00
|
|
|
Node* CodeStubAssembler::SmiMin(Node* a, Node* b) {
|
|
|
|
// TODO(bmeurer): Consider using Select once available.
|
|
|
|
Variable min(this, MachineRepresentation::kTagged);
|
|
|
|
Label if_a(this), if_b(this), join(this);
|
|
|
|
BranchIfSmiLessThan(a, b, &if_a, &if_b);
|
|
|
|
Bind(&if_a);
|
|
|
|
min.Bind(a);
|
|
|
|
Goto(&join);
|
|
|
|
Bind(&if_b);
|
|
|
|
min.Bind(b);
|
|
|
|
Goto(&join);
|
|
|
|
Bind(&join);
|
|
|
|
return min.value();
|
|
|
|
}
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
#define DEFINE_CODE_STUB_ASSEMBER_BINARY_OP(name) \
|
|
|
|
Node* CodeStubAssembler::name(Node* a, Node* b) { \
|
|
|
|
return raw_assembler_->name(a, b); \
|
|
|
|
}
|
|
|
|
CODE_STUB_ASSEMBLER_BINARY_OP_LIST(DEFINE_CODE_STUB_ASSEMBER_BINARY_OP)
|
|
|
|
#undef DEFINE_CODE_STUB_ASSEMBER_BINARY_OP
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
Node* CodeStubAssembler::WordShl(Node* value, int shift) {
|
2016-03-01 07:08:20 +00:00
|
|
|
return raw_assembler_->WordShl(value, IntPtrConstant(shift));
|
2015-12-02 12:35:12 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 22:04:55 +00:00
|
|
|
#define DEFINE_CODE_STUB_ASSEMBER_UNARY_OP(name) \
|
|
|
|
Node* CodeStubAssembler::name(Node* a) { return raw_assembler_->name(a); }
|
|
|
|
CODE_STUB_ASSEMBLER_UNARY_OP_LIST(DEFINE_CODE_STUB_ASSEMBER_UNARY_OP)
|
|
|
|
#undef DEFINE_CODE_STUB_ASSEMBER_UNARY_OP
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
Node* CodeStubAssembler::WordIsSmi(Node* a) {
|
2016-03-01 07:08:20 +00:00
|
|
|
return WordEqual(raw_assembler_->WordAnd(a, IntPtrConstant(kSmiTagMask)),
|
|
|
|
IntPtrConstant(0));
|
2015-12-02 12:35:12 +00:00
|
|
|
}
|
|
|
|
|
2016-03-21 13:33:02 +00:00
|
|
|
Node* CodeStubAssembler::WordIsPositiveSmi(Node* a) {
|
|
|
|
return WordEqual(
|
|
|
|
raw_assembler_->WordAnd(a, IntPtrConstant(kSmiTagMask | kSmiSignMask)),
|
|
|
|
IntPtrConstant(0));
|
|
|
|
}
|
|
|
|
|
2016-03-17 11:04:51 +00:00
|
|
|
Node* CodeStubAssembler::LoadBufferObject(Node* buffer, int offset,
|
|
|
|
MachineType rep) {
|
|
|
|
return raw_assembler_->Load(rep, buffer, IntPtrConstant(offset));
|
2015-12-02 12:35:12 +00:00
|
|
|
}
|
|
|
|
|
2016-03-17 11:04:51 +00:00
|
|
|
Node* CodeStubAssembler::LoadObjectField(Node* object, int offset,
|
|
|
|
MachineType rep) {
|
|
|
|
return raw_assembler_->Load(rep, object,
|
2015-12-02 12:35:12 +00:00
|
|
|
IntPtrConstant(offset - kHeapObjectTag));
|
|
|
|
}
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::StoreObjectFieldNoWriteBarrier(
|
|
|
|
Node* object, int offset, Node* value, MachineRepresentation rep) {
|
|
|
|
return StoreNoWriteBarrier(rep, object,
|
|
|
|
IntPtrConstant(offset - kHeapObjectTag), value);
|
|
|
|
}
|
|
|
|
|
2016-03-01 22:04:55 +00:00
|
|
|
Node* CodeStubAssembler::LoadHeapNumberValue(Node* object) {
|
2016-03-02 11:46:57 +00:00
|
|
|
return Load(MachineType::Float64(), object,
|
|
|
|
IntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag));
|
|
|
|
}
|
|
|
|
|
2016-03-22 13:25:05 +00:00
|
|
|
Node* CodeStubAssembler::StoreHeapNumberValue(Node* object, Node* value) {
|
|
|
|
return StoreNoWriteBarrier(
|
|
|
|
MachineRepresentation::kFloat64, object,
|
|
|
|
IntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag), value);
|
|
|
|
}
|
|
|
|
|
2016-03-24 06:05:03 +00:00
|
|
|
Node* CodeStubAssembler::TruncateHeapNumberValueToWord32(Node* object) {
|
2016-03-23 13:44:32 +00:00
|
|
|
Node* value = LoadHeapNumberValue(object);
|
|
|
|
return raw_assembler_->TruncateFloat64ToInt32(TruncationMode::kJavaScript,
|
|
|
|
value);
|
|
|
|
}
|
|
|
|
|
2016-03-16 09:36:52 +00:00
|
|
|
Node* CodeStubAssembler::LoadMapBitField(Node* map) {
|
|
|
|
return Load(MachineType::Uint8(), map,
|
|
|
|
IntPtrConstant(Map::kBitFieldOffset - kHeapObjectTag));
|
|
|
|
}
|
|
|
|
|
2016-03-31 07:53:10 +00:00
|
|
|
Node* CodeStubAssembler::LoadMapBitField2(Node* map) {
|
|
|
|
return Load(MachineType::Uint8(), map,
|
|
|
|
IntPtrConstant(Map::kBitField2Offset - kHeapObjectTag));
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::LoadMapBitField3(Node* map) {
|
|
|
|
return Load(MachineType::Uint32(), map,
|
|
|
|
IntPtrConstant(Map::kBitField3Offset - kHeapObjectTag));
|
|
|
|
}
|
|
|
|
|
2016-03-02 11:46:57 +00:00
|
|
|
Node* CodeStubAssembler::LoadMapInstanceType(Node* map) {
|
|
|
|
return Load(MachineType::Uint8(), map,
|
|
|
|
IntPtrConstant(Map::kInstanceTypeOffset - kHeapObjectTag));
|
2016-03-01 22:04:55 +00:00
|
|
|
}
|
|
|
|
|
2016-03-31 07:53:10 +00:00
|
|
|
Node* CodeStubAssembler::LoadMapDescriptors(Node* map) {
|
|
|
|
return LoadObjectField(map, Map::kDescriptorsOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::LoadNameHash(Node* name) {
|
|
|
|
return Load(MachineType::Uint32(), name,
|
|
|
|
IntPtrConstant(Name::kHashFieldOffset - kHeapObjectTag));
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::LoadFixedArrayElementInt32Index(
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* object, Node* index, int additional_offset) {
|
2016-03-31 07:53:10 +00:00
|
|
|
Node* header_size = IntPtrConstant(additional_offset +
|
|
|
|
FixedArray::kHeaderSize - kHeapObjectTag);
|
2016-04-12 10:29:49 +00:00
|
|
|
if (raw_assembler_->machine()->Is64()) {
|
|
|
|
index = ChangeInt32ToInt64(index);
|
|
|
|
}
|
|
|
|
Node* scaled_index = WordShl(index, IntPtrConstant(kPointerSizeLog2));
|
2016-03-31 07:53:10 +00:00
|
|
|
Node* offset = IntPtrAdd(scaled_index, header_size);
|
|
|
|
return Load(MachineType::AnyTagged(), object, offset);
|
|
|
|
}
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
Node* CodeStubAssembler::LoadFixedArrayElementSmiIndex(Node* object,
|
|
|
|
Node* smi_index,
|
|
|
|
int additional_offset) {
|
2016-03-01 07:08:20 +00:00
|
|
|
int const kSmiShiftBits = kSmiShiftSize + kSmiTagSize;
|
|
|
|
Node* header_size = IntPtrConstant(additional_offset +
|
|
|
|
FixedArray::kHeaderSize - kHeapObjectTag);
|
2016-02-02 09:42:13 +00:00
|
|
|
Node* scaled_index =
|
2016-03-01 07:08:20 +00:00
|
|
|
(kSmiShiftBits > kPointerSizeLog2)
|
|
|
|
? WordSar(smi_index, IntPtrConstant(kSmiShiftBits - kPointerSizeLog2))
|
|
|
|
: WordShl(smi_index,
|
|
|
|
IntPtrConstant(kPointerSizeLog2 - kSmiShiftBits));
|
|
|
|
Node* offset = IntPtrAdd(scaled_index, header_size);
|
|
|
|
return Load(MachineType::AnyTagged(), object, offset);
|
2016-02-02 09:42:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::LoadFixedArrayElementConstantIndex(Node* object,
|
|
|
|
int index) {
|
2016-03-01 07:08:20 +00:00
|
|
|
Node* offset = IntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag +
|
|
|
|
index * kPointerSize);
|
2016-02-02 09:42:13 +00:00
|
|
|
return raw_assembler_->Load(MachineType::AnyTagged(), object, offset);
|
|
|
|
}
|
|
|
|
|
2016-03-01 13:55:48 +00:00
|
|
|
Node* CodeStubAssembler::StoreFixedArrayElementNoWriteBarrier(Node* object,
|
|
|
|
Node* index,
|
|
|
|
Node* value) {
|
|
|
|
Node* offset =
|
|
|
|
IntPtrAdd(WordShl(index, IntPtrConstant(kPointerSizeLog2)),
|
|
|
|
IntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag));
|
|
|
|
return StoreNoWriteBarrier(MachineRepresentation::kTagged, object, offset,
|
|
|
|
value);
|
|
|
|
}
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::StoreFixedArrayElementInt32Index(Node* object,
|
|
|
|
Node* index,
|
|
|
|
Node* value) {
|
|
|
|
if (raw_assembler_->machine()->Is64()) {
|
|
|
|
index = ChangeInt32ToInt64(index);
|
|
|
|
}
|
|
|
|
Node* offset =
|
|
|
|
IntPtrAdd(WordShl(index, IntPtrConstant(kPointerSizeLog2)),
|
|
|
|
IntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag));
|
|
|
|
return Store(MachineRepresentation::kTagged, object, offset, value);
|
|
|
|
}
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
Node* CodeStubAssembler::LoadRoot(Heap::RootListIndex root_index) {
|
|
|
|
if (isolate()->heap()->RootCanBeTreatedAsConstant(root_index)) {
|
|
|
|
Handle<Object> root = isolate()->heap()->root_handle(root_index);
|
|
|
|
if (root->IsSmi()) {
|
2016-03-01 07:08:20 +00:00
|
|
|
return SmiConstant(Smi::cast(*root));
|
2016-02-02 09:42:13 +00:00
|
|
|
} else {
|
|
|
|
return HeapConstant(Handle<HeapObject>::cast(root));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
compiler::Node* roots_array_start =
|
|
|
|
ExternalConstant(ExternalReference::roots_array_start(isolate()));
|
|
|
|
USE(roots_array_start);
|
|
|
|
|
|
|
|
// TODO(danno): Implement thee root-access case where the root is not constant
|
|
|
|
// and must be loaded from the root array.
|
|
|
|
UNIMPLEMENTED();
|
|
|
|
return nullptr;
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-03-02 12:16:16 +00:00
|
|
|
Node* CodeStubAssembler::AllocateRawUnaligned(Node* size_in_bytes,
|
|
|
|
AllocationFlags flags,
|
|
|
|
Node* top_address,
|
|
|
|
Node* limit_address) {
|
|
|
|
Node* top = Load(MachineType::Pointer(), top_address);
|
|
|
|
Node* limit = Load(MachineType::Pointer(), limit_address);
|
|
|
|
|
|
|
|
// If there's not enough space, call the runtime.
|
2016-03-10 12:23:02 +00:00
|
|
|
RawMachineLabel runtime_call(RawMachineLabel::kDeferred), no_runtime_call,
|
|
|
|
merge_runtime;
|
2016-03-02 12:16:16 +00:00
|
|
|
raw_assembler_->Branch(
|
|
|
|
raw_assembler_->IntPtrLessThan(IntPtrSub(limit, top), size_in_bytes),
|
|
|
|
&runtime_call, &no_runtime_call);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(&runtime_call);
|
|
|
|
// AllocateInTargetSpace does not use the context.
|
|
|
|
Node* context = IntPtrConstant(0);
|
|
|
|
Node* runtime_flags = SmiTag(Int32Constant(
|
|
|
|
AllocateDoubleAlignFlag::encode(false) |
|
|
|
|
AllocateTargetSpace::encode(flags & kPretenured
|
|
|
|
? AllocationSpace::OLD_SPACE
|
|
|
|
: AllocationSpace::NEW_SPACE)));
|
|
|
|
Node* runtime_result = CallRuntime(Runtime::kAllocateInTargetSpace, context,
|
|
|
|
SmiTag(size_in_bytes), runtime_flags);
|
|
|
|
raw_assembler_->Goto(&merge_runtime);
|
|
|
|
|
|
|
|
// When there is enough space, return `top' and bump it up.
|
|
|
|
raw_assembler_->Bind(&no_runtime_call);
|
|
|
|
Node* no_runtime_result = top;
|
|
|
|
StoreNoWriteBarrier(MachineType::PointerRepresentation(), top_address,
|
|
|
|
IntPtrAdd(top, size_in_bytes));
|
|
|
|
no_runtime_result =
|
|
|
|
IntPtrAdd(no_runtime_result, IntPtrConstant(kHeapObjectTag));
|
|
|
|
raw_assembler_->Goto(&merge_runtime);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(&merge_runtime);
|
|
|
|
return raw_assembler_->Phi(MachineType::PointerRepresentation(),
|
|
|
|
runtime_result, no_runtime_result);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::AllocateRawAligned(Node* size_in_bytes,
|
|
|
|
AllocationFlags flags,
|
|
|
|
Node* top_address,
|
|
|
|
Node* limit_address) {
|
|
|
|
Node* top = Load(MachineType::Pointer(), top_address);
|
|
|
|
Node* limit = Load(MachineType::Pointer(), limit_address);
|
|
|
|
Node* adjusted_size = size_in_bytes;
|
|
|
|
if (flags & kDoubleAlignment) {
|
|
|
|
// TODO(epertoso): Simd128 alignment.
|
|
|
|
RawMachineLabel aligned, not_aligned, merge;
|
|
|
|
raw_assembler_->Branch(WordAnd(top, IntPtrConstant(kDoubleAlignmentMask)),
|
|
|
|
¬_aligned, &aligned);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(¬_aligned);
|
|
|
|
Node* not_aligned_size =
|
|
|
|
IntPtrAdd(size_in_bytes, IntPtrConstant(kPointerSize));
|
|
|
|
raw_assembler_->Goto(&merge);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(&aligned);
|
|
|
|
raw_assembler_->Goto(&merge);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(&merge);
|
|
|
|
adjusted_size = raw_assembler_->Phi(MachineType::PointerRepresentation(),
|
|
|
|
not_aligned_size, adjusted_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* address = AllocateRawUnaligned(adjusted_size, kNone, top, limit);
|
|
|
|
|
|
|
|
RawMachineLabel needs_filler, doesnt_need_filler, merge_address;
|
|
|
|
raw_assembler_->Branch(
|
|
|
|
raw_assembler_->IntPtrEqual(adjusted_size, size_in_bytes),
|
|
|
|
&doesnt_need_filler, &needs_filler);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(&needs_filler);
|
|
|
|
// Store a filler and increase the address by kPointerSize.
|
|
|
|
// TODO(epertoso): this code assumes that we only align to kDoubleSize. Change
|
|
|
|
// it when Simd128 alignment is supported.
|
|
|
|
StoreNoWriteBarrier(MachineType::PointerRepresentation(), top,
|
|
|
|
LoadRoot(Heap::kOnePointerFillerMapRootIndex));
|
|
|
|
Node* address_with_filler = IntPtrAdd(address, IntPtrConstant(kPointerSize));
|
|
|
|
raw_assembler_->Goto(&merge_address);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(&doesnt_need_filler);
|
|
|
|
Node* address_without_filler = address;
|
|
|
|
raw_assembler_->Goto(&merge_address);
|
|
|
|
|
|
|
|
raw_assembler_->Bind(&merge_address);
|
|
|
|
address = raw_assembler_->Phi(MachineType::PointerRepresentation(),
|
|
|
|
address_with_filler, address_without_filler);
|
|
|
|
// Update the top.
|
|
|
|
StoreNoWriteBarrier(MachineType::PointerRepresentation(), top_address,
|
|
|
|
IntPtrAdd(top, adjusted_size));
|
|
|
|
return address;
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Allocate(int size_in_bytes, AllocationFlags flags) {
|
|
|
|
bool const new_space = !(flags & kPretenured);
|
|
|
|
Node* top_address = ExternalConstant(
|
|
|
|
new_space
|
|
|
|
? ExternalReference::new_space_allocation_top_address(isolate())
|
|
|
|
: ExternalReference::old_space_allocation_top_address(isolate()));
|
|
|
|
Node* limit_address = ExternalConstant(
|
|
|
|
new_space
|
|
|
|
? ExternalReference::new_space_allocation_limit_address(isolate())
|
|
|
|
: ExternalReference::old_space_allocation_limit_address(isolate()));
|
|
|
|
|
|
|
|
#ifdef V8_HOST_ARCH_32_BIT
|
|
|
|
if (flags & kDoubleAlignment) {
|
|
|
|
return AllocateRawAligned(IntPtrConstant(size_in_bytes), flags, top_address,
|
|
|
|
limit_address);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return AllocateRawUnaligned(IntPtrConstant(size_in_bytes), flags, top_address,
|
|
|
|
limit_address);
|
|
|
|
}
|
|
|
|
|
2016-03-23 06:14:37 +00:00
|
|
|
Node* CodeStubAssembler::AllocateHeapNumber() {
|
|
|
|
Node* result = Allocate(HeapNumber::kSize, kNone);
|
|
|
|
StoreMapNoWriteBarrier(result, HeapNumberMapConstant());
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::AllocateHeapNumberWithValue(Node* value) {
|
|
|
|
Node* result = AllocateHeapNumber();
|
|
|
|
StoreHeapNumberValue(result, value);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::AllocateSeqOneByteString(int length) {
|
|
|
|
Node* result = Allocate(SeqOneByteString::SizeFor(length));
|
|
|
|
StoreMapNoWriteBarrier(result, LoadRoot(Heap::kOneByteStringMapRootIndex));
|
|
|
|
StoreObjectFieldNoWriteBarrier(result, SeqOneByteString::kLengthOffset,
|
|
|
|
SmiConstant(Smi::FromInt(length)));
|
|
|
|
StoreObjectFieldNoWriteBarrier(result, SeqOneByteString::kHashFieldOffset,
|
|
|
|
IntPtrConstant(String::kEmptyHashField));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::AllocateSeqTwoByteString(int length) {
|
|
|
|
Node* result = Allocate(SeqTwoByteString::SizeFor(length));
|
|
|
|
StoreMapNoWriteBarrier(result, LoadRoot(Heap::kStringMapRootIndex));
|
|
|
|
StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kLengthOffset,
|
|
|
|
SmiConstant(Smi::FromInt(length)));
|
|
|
|
StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kHashFieldOffset,
|
|
|
|
IntPtrConstant(String::kEmptyHashField));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2016-02-10 16:38:49 +00:00
|
|
|
Node* CodeStubAssembler::Load(MachineType rep, Node* base) {
|
|
|
|
return raw_assembler_->Load(rep, base);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Load(MachineType rep, Node* base, Node* index) {
|
|
|
|
return raw_assembler_->Load(rep, base, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Store(MachineRepresentation rep, Node* base,
|
|
|
|
Node* value) {
|
|
|
|
return raw_assembler_->Store(rep, base, value, kFullWriteBarrier);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Store(MachineRepresentation rep, Node* base,
|
|
|
|
Node* index, Node* value) {
|
|
|
|
return raw_assembler_->Store(rep, base, index, value, kFullWriteBarrier);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::StoreNoWriteBarrier(MachineRepresentation rep,
|
|
|
|
Node* base, Node* value) {
|
|
|
|
return raw_assembler_->Store(rep, base, value, kNoWriteBarrier);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::StoreNoWriteBarrier(MachineRepresentation rep,
|
|
|
|
Node* base, Node* index,
|
|
|
|
Node* value) {
|
|
|
|
return raw_assembler_->Store(rep, base, index, value, kNoWriteBarrier);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Projection(int index, Node* value) {
|
|
|
|
return raw_assembler_->Projection(index, value);
|
|
|
|
}
|
|
|
|
|
2016-03-16 09:36:52 +00:00
|
|
|
Node* CodeStubAssembler::LoadMap(Node* object) {
|
|
|
|
return LoadObjectField(object, HeapObject::kMapOffset);
|
|
|
|
}
|
|
|
|
|
2016-03-22 13:25:05 +00:00
|
|
|
Node* CodeStubAssembler::StoreMapNoWriteBarrier(Node* object, Node* map) {
|
|
|
|
return StoreNoWriteBarrier(
|
|
|
|
MachineRepresentation::kTagged, object,
|
|
|
|
IntPtrConstant(HeapNumber::kMapOffset - kHeapObjectTag), map);
|
|
|
|
}
|
|
|
|
|
2016-03-01 22:04:55 +00:00
|
|
|
Node* CodeStubAssembler::LoadInstanceType(Node* object) {
|
2016-03-16 09:36:52 +00:00
|
|
|
return LoadMapInstanceType(LoadMap(object));
|
2016-03-01 22:04:55 +00:00
|
|
|
}
|
|
|
|
|
2016-03-31 07:53:10 +00:00
|
|
|
Node* CodeStubAssembler::LoadElements(Node* object) {
|
|
|
|
return LoadObjectField(object, JSObject::kElementsOffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::LoadFixedArrayBaseLength(Node* array) {
|
|
|
|
return LoadObjectField(array, FixedArrayBase::kLengthOffset);
|
|
|
|
}
|
|
|
|
|
2016-03-01 22:04:55 +00:00
|
|
|
Node* CodeStubAssembler::BitFieldDecode(Node* word32, uint32_t shift,
|
|
|
|
uint32_t mask) {
|
|
|
|
return raw_assembler_->Word32Shr(
|
|
|
|
raw_assembler_->Word32And(word32, raw_assembler_->Int32Constant(mask)),
|
|
|
|
raw_assembler_->Int32Constant(shift));
|
|
|
|
}
|
|
|
|
|
2016-03-28 17:30:05 +00:00
|
|
|
Node* CodeStubAssembler::ChangeFloat64ToTagged(Node* value) {
|
|
|
|
Node* value32 = raw_assembler_->TruncateFloat64ToInt32(
|
|
|
|
TruncationMode::kRoundToZero, value);
|
|
|
|
Node* value64 = ChangeInt32ToFloat64(value32);
|
|
|
|
|
|
|
|
Label if_valueisint32(this), if_valueisheapnumber(this), if_join(this);
|
|
|
|
|
|
|
|
Label if_valueisequal(this), if_valueisnotequal(this);
|
|
|
|
Branch(Float64Equal(value, value64), &if_valueisequal, &if_valueisnotequal);
|
|
|
|
Bind(&if_valueisequal);
|
|
|
|
{
|
|
|
|
Label if_valueiszero(this), if_valueisnotzero(this);
|
|
|
|
Branch(Float64Equal(value, Float64Constant(0.0)), &if_valueiszero,
|
|
|
|
&if_valueisnotzero);
|
|
|
|
|
|
|
|
Bind(&if_valueiszero);
|
|
|
|
BranchIfInt32LessThan(raw_assembler_->Float64ExtractHighWord32(value),
|
|
|
|
Int32Constant(0), &if_valueisheapnumber,
|
|
|
|
&if_valueisint32);
|
|
|
|
|
|
|
|
Bind(&if_valueisnotzero);
|
|
|
|
Goto(&if_valueisint32);
|
|
|
|
}
|
|
|
|
Bind(&if_valueisnotequal);
|
|
|
|
Goto(&if_valueisheapnumber);
|
|
|
|
|
|
|
|
Variable var_result(this, MachineRepresentation::kTagged);
|
|
|
|
Bind(&if_valueisint32);
|
|
|
|
{
|
|
|
|
if (raw_assembler_->machine()->Is64()) {
|
|
|
|
Node* result = SmiTag(ChangeInt32ToInt64(value32));
|
|
|
|
var_result.Bind(result);
|
|
|
|
Goto(&if_join);
|
|
|
|
} else {
|
|
|
|
Node* pair = Int32AddWithOverflow(value32, value32);
|
|
|
|
Node* overflow = Projection(1, pair);
|
2016-03-31 17:23:10 +00:00
|
|
|
Label if_overflow(this, Label::kDeferred), if_notoverflow(this);
|
2016-03-28 17:30:05 +00:00
|
|
|
Branch(overflow, &if_overflow, &if_notoverflow);
|
|
|
|
Bind(&if_overflow);
|
|
|
|
Goto(&if_valueisheapnumber);
|
|
|
|
Bind(&if_notoverflow);
|
|
|
|
{
|
|
|
|
Node* result = Projection(0, pair);
|
|
|
|
var_result.Bind(result);
|
|
|
|
Goto(&if_join);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&if_valueisheapnumber);
|
|
|
|
{
|
|
|
|
Node* result = AllocateHeapNumberWithValue(value);
|
|
|
|
var_result.Bind(result);
|
|
|
|
Goto(&if_join);
|
|
|
|
}
|
|
|
|
Bind(&if_join);
|
|
|
|
return var_result.value();
|
|
|
|
}
|
|
|
|
|
2016-03-23 13:44:32 +00:00
|
|
|
Node* CodeStubAssembler::ChangeInt32ToTagged(Node* value) {
|
|
|
|
if (raw_assembler_->machine()->Is64()) {
|
|
|
|
return SmiTag(ChangeInt32ToInt64(value));
|
|
|
|
}
|
|
|
|
Variable var_result(this, MachineRepresentation::kTagged);
|
|
|
|
Node* pair = Int32AddWithOverflow(value, value);
|
|
|
|
Node* overflow = Projection(1, pair);
|
|
|
|
Label if_overflow(this, Label::kDeferred), if_notoverflow(this),
|
|
|
|
if_join(this);
|
|
|
|
Branch(overflow, &if_overflow, &if_notoverflow);
|
|
|
|
Bind(&if_overflow);
|
|
|
|
{
|
|
|
|
Node* value64 = ChangeInt32ToFloat64(value);
|
|
|
|
Node* result = AllocateHeapNumberWithValue(value64);
|
|
|
|
var_result.Bind(result);
|
|
|
|
}
|
|
|
|
Goto(&if_join);
|
|
|
|
Bind(&if_notoverflow);
|
|
|
|
{
|
|
|
|
Node* result = Projection(0, pair);
|
|
|
|
var_result.Bind(result);
|
|
|
|
}
|
|
|
|
Goto(&if_join);
|
|
|
|
Bind(&if_join);
|
|
|
|
return var_result.value();
|
|
|
|
}
|
|
|
|
|
2016-04-13 13:51:23 +00:00
|
|
|
Node* CodeStubAssembler::ChangeUint32ToTagged(Node* value) {
|
|
|
|
Label if_overflow(this, Label::kDeferred), if_not_overflow(this),
|
|
|
|
if_join(this);
|
|
|
|
Variable var_result(this, MachineRepresentation::kTagged);
|
|
|
|
// If {value} > 2^31 - 1, we need to store it in a HeapNumber.
|
|
|
|
Branch(Int32LessThan(value, Int32Constant(0)), &if_overflow,
|
|
|
|
&if_not_overflow);
|
|
|
|
Bind(&if_not_overflow);
|
|
|
|
{
|
|
|
|
if (raw_assembler_->machine()->Is64()) {
|
|
|
|
var_result.Bind(SmiTag(ChangeUint32ToUint64(value)));
|
|
|
|
} else {
|
|
|
|
// If tagging {value} results in an overflow, we need to use a HeapNumber
|
|
|
|
// to represent it.
|
|
|
|
Node* pair = Int32AddWithOverflow(value, value);
|
|
|
|
Node* overflow = Projection(1, pair);
|
|
|
|
GotoIf(overflow, &if_overflow);
|
|
|
|
|
|
|
|
Node* result = Projection(0, pair);
|
|
|
|
var_result.Bind(result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Goto(&if_join);
|
|
|
|
|
|
|
|
Bind(&if_overflow);
|
|
|
|
{
|
|
|
|
Node* float64_value = ChangeUint32ToFloat64(value);
|
|
|
|
var_result.Bind(AllocateHeapNumberWithValue(float64_value));
|
|
|
|
}
|
|
|
|
Goto(&if_join);
|
|
|
|
|
|
|
|
Bind(&if_join);
|
|
|
|
return var_result.value();
|
|
|
|
}
|
|
|
|
|
2016-03-24 06:05:03 +00:00
|
|
|
Node* CodeStubAssembler::TruncateTaggedToFloat64(Node* context, Node* value) {
|
|
|
|
// We might need to loop once due to ToNumber conversion.
|
|
|
|
Variable var_value(this, MachineRepresentation::kTagged),
|
|
|
|
var_result(this, MachineRepresentation::kFloat64);
|
|
|
|
Label loop(this, &var_value), done_loop(this, &var_result);
|
|
|
|
var_value.Bind(value);
|
|
|
|
Goto(&loop);
|
|
|
|
Bind(&loop);
|
|
|
|
{
|
|
|
|
// Load the current {value}.
|
|
|
|
value = var_value.value();
|
|
|
|
|
|
|
|
// Check if the {value} is a Smi or a HeapObject.
|
|
|
|
Label if_valueissmi(this), if_valueisnotsmi(this);
|
|
|
|
Branch(WordIsSmi(value), &if_valueissmi, &if_valueisnotsmi);
|
|
|
|
|
|
|
|
Bind(&if_valueissmi);
|
|
|
|
{
|
|
|
|
// Convert the Smi {value}.
|
|
|
|
var_result.Bind(SmiToFloat64(value));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_valueisnotsmi);
|
|
|
|
{
|
|
|
|
// Check if {value} is a HeapNumber.
|
|
|
|
Label if_valueisheapnumber(this),
|
|
|
|
if_valueisnotheapnumber(this, Label::kDeferred);
|
|
|
|
Branch(WordEqual(LoadMap(value), HeapNumberMapConstant()),
|
|
|
|
&if_valueisheapnumber, &if_valueisnotheapnumber);
|
|
|
|
|
|
|
|
Bind(&if_valueisheapnumber);
|
|
|
|
{
|
|
|
|
// Load the floating point value.
|
|
|
|
var_result.Bind(LoadHeapNumberValue(value));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_valueisnotheapnumber);
|
|
|
|
{
|
|
|
|
// Convert the {value} to a Number first.
|
|
|
|
Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
|
|
|
var_value.Bind(CallStub(callable, context, value));
|
|
|
|
Goto(&loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&done_loop);
|
|
|
|
return var_result.value();
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::TruncateTaggedToWord32(Node* context, Node* value) {
|
|
|
|
// We might need to loop once due to ToNumber conversion.
|
|
|
|
Variable var_value(this, MachineRepresentation::kTagged),
|
|
|
|
var_result(this, MachineRepresentation::kWord32);
|
|
|
|
Label loop(this, &var_value), done_loop(this, &var_result);
|
|
|
|
var_value.Bind(value);
|
|
|
|
Goto(&loop);
|
|
|
|
Bind(&loop);
|
|
|
|
{
|
|
|
|
// Load the current {value}.
|
|
|
|
value = var_value.value();
|
|
|
|
|
|
|
|
// Check if the {value} is a Smi or a HeapObject.
|
|
|
|
Label if_valueissmi(this), if_valueisnotsmi(this);
|
|
|
|
Branch(WordIsSmi(value), &if_valueissmi, &if_valueisnotsmi);
|
|
|
|
|
|
|
|
Bind(&if_valueissmi);
|
|
|
|
{
|
|
|
|
// Convert the Smi {value}.
|
|
|
|
var_result.Bind(SmiToWord32(value));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_valueisnotsmi);
|
|
|
|
{
|
|
|
|
// Check if {value} is a HeapNumber.
|
|
|
|
Label if_valueisheapnumber(this),
|
|
|
|
if_valueisnotheapnumber(this, Label::kDeferred);
|
|
|
|
Branch(WordEqual(LoadMap(value), HeapNumberMapConstant()),
|
|
|
|
&if_valueisheapnumber, &if_valueisnotheapnumber);
|
|
|
|
|
|
|
|
Bind(&if_valueisheapnumber);
|
|
|
|
{
|
|
|
|
// Truncate the floating point value.
|
|
|
|
var_result.Bind(TruncateHeapNumberValueToWord32(value));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_valueisnotheapnumber);
|
|
|
|
{
|
|
|
|
// Convert the {value} to a Number first.
|
|
|
|
Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
|
|
|
var_value.Bind(CallStub(callable, context, value));
|
|
|
|
Goto(&loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&done_loop);
|
|
|
|
return var_result.value();
|
|
|
|
}
|
|
|
|
|
2016-04-12 10:29:49 +00:00
|
|
|
Node* CodeStubAssembler::ToThisString(Node* context, Node* value,
|
|
|
|
char const* method_name) {
|
|
|
|
Variable var_value(this, MachineRepresentation::kTagged);
|
|
|
|
var_value.Bind(value);
|
|
|
|
|
|
|
|
// Check if the {value} is a Smi or a HeapObject.
|
|
|
|
Label if_valueissmi(this, Label::kDeferred), if_valueisnotsmi(this),
|
|
|
|
if_valueisstring(this);
|
|
|
|
Branch(WordIsSmi(value), &if_valueissmi, &if_valueisnotsmi);
|
|
|
|
Bind(&if_valueisnotsmi);
|
|
|
|
{
|
|
|
|
// Load the instance type of the {value}.
|
|
|
|
Node* value_instance_type = LoadInstanceType(value);
|
|
|
|
|
|
|
|
// Check if the {value} is already String.
|
|
|
|
Label if_valueisnotstring(this, Label::kDeferred);
|
|
|
|
Branch(
|
|
|
|
Int32LessThan(value_instance_type, Int32Constant(FIRST_NONSTRING_TYPE)),
|
|
|
|
&if_valueisstring, &if_valueisnotstring);
|
|
|
|
Bind(&if_valueisnotstring);
|
|
|
|
{
|
|
|
|
// Check if the {value} is null.
|
|
|
|
Label if_valueisnullorundefined(this, Label::kDeferred),
|
|
|
|
if_valueisnotnullorundefined(this, Label::kDeferred),
|
|
|
|
if_valueisnotnull(this, Label::kDeferred);
|
|
|
|
Branch(WordEqual(value, NullConstant()), &if_valueisnullorundefined,
|
|
|
|
&if_valueisnotnull);
|
|
|
|
Bind(&if_valueisnotnull);
|
|
|
|
{
|
|
|
|
// Check if the {value} is undefined.
|
|
|
|
Branch(WordEqual(value, UndefinedConstant()),
|
|
|
|
&if_valueisnullorundefined, &if_valueisnotnullorundefined);
|
|
|
|
Bind(&if_valueisnotnullorundefined);
|
|
|
|
{
|
|
|
|
// Convert the {value} to a String.
|
|
|
|
Callable callable = CodeFactory::ToString(isolate());
|
|
|
|
var_value.Bind(CallStub(callable, context, value));
|
|
|
|
Goto(&if_valueisstring);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_valueisnullorundefined);
|
|
|
|
{
|
|
|
|
// The {value} is either null or undefined.
|
|
|
|
CallRuntime(Runtime::kThrowCalledOnNullOrUndefined, context,
|
|
|
|
HeapConstant(factory()->NewStringFromAsciiChecked(
|
|
|
|
method_name, TENURED)));
|
|
|
|
Goto(&if_valueisstring); // Never reached.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bind(&if_valueissmi);
|
|
|
|
{
|
|
|
|
// The {value} is a Smi, convert it to a String.
|
|
|
|
Callable callable = CodeFactory::NumberToString(isolate());
|
|
|
|
var_value.Bind(CallStub(callable, context, value));
|
|
|
|
Goto(&if_valueisstring);
|
|
|
|
}
|
|
|
|
Bind(&if_valueisstring);
|
|
|
|
return var_value.value();
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::StringCharCodeAt(Node* string, Node* index) {
|
|
|
|
// Translate the {index} into a Word.
|
|
|
|
index = SmiToWord(index);
|
|
|
|
|
|
|
|
// We may need to loop in case of cons or sliced strings.
|
|
|
|
Variable var_index(this, MachineType::PointerRepresentation());
|
|
|
|
Variable var_result(this, MachineRepresentation::kWord32);
|
|
|
|
Variable var_string(this, MachineRepresentation::kTagged);
|
|
|
|
Variable* loop_vars[] = {&var_index, &var_string};
|
|
|
|
Label done_loop(this, &var_result), loop(this, 2, loop_vars);
|
|
|
|
var_string.Bind(string);
|
|
|
|
var_index.Bind(index);
|
|
|
|
Goto(&loop);
|
|
|
|
Bind(&loop);
|
|
|
|
{
|
|
|
|
// Load the current {index}.
|
|
|
|
index = var_index.value();
|
|
|
|
|
|
|
|
// Load the current {string}.
|
|
|
|
string = var_string.value();
|
|
|
|
|
|
|
|
// Load the instance type of the {string}.
|
|
|
|
Node* string_instance_type = LoadInstanceType(string);
|
|
|
|
|
|
|
|
// Check if the {string} is a SeqString.
|
|
|
|
Label if_stringissequential(this), if_stringisnotsequential(this);
|
|
|
|
Branch(Word32Equal(Word32And(string_instance_type,
|
|
|
|
Int32Constant(kStringRepresentationMask)),
|
|
|
|
Int32Constant(kSeqStringTag)),
|
|
|
|
&if_stringissequential, &if_stringisnotsequential);
|
|
|
|
|
|
|
|
Bind(&if_stringissequential);
|
|
|
|
{
|
|
|
|
// Check if the {string} is a TwoByteSeqString or a OneByteSeqString.
|
|
|
|
Label if_stringistwobyte(this), if_stringisonebyte(this);
|
|
|
|
Branch(Word32Equal(Word32And(string_instance_type,
|
|
|
|
Int32Constant(kStringEncodingMask)),
|
|
|
|
Int32Constant(kTwoByteStringTag)),
|
|
|
|
&if_stringistwobyte, &if_stringisonebyte);
|
|
|
|
|
|
|
|
Bind(&if_stringisonebyte);
|
|
|
|
{
|
|
|
|
var_result.Bind(
|
|
|
|
Load(MachineType::Uint8(), string,
|
|
|
|
IntPtrAdd(index, IntPtrConstant(SeqOneByteString::kHeaderSize -
|
|
|
|
kHeapObjectTag))));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_stringistwobyte);
|
|
|
|
{
|
|
|
|
var_result.Bind(
|
|
|
|
Load(MachineType::Uint16(), string,
|
|
|
|
IntPtrAdd(WordShl(index, IntPtrConstant(1)),
|
|
|
|
IntPtrConstant(SeqTwoByteString::kHeaderSize -
|
|
|
|
kHeapObjectTag))));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_stringisnotsequential);
|
|
|
|
{
|
|
|
|
// Check if the {string} is a ConsString.
|
|
|
|
Label if_stringiscons(this), if_stringisnotcons(this);
|
|
|
|
Branch(Word32Equal(Word32And(string_instance_type,
|
|
|
|
Int32Constant(kStringRepresentationMask)),
|
|
|
|
Int32Constant(kConsStringTag)),
|
|
|
|
&if_stringiscons, &if_stringisnotcons);
|
|
|
|
|
|
|
|
Bind(&if_stringiscons);
|
|
|
|
{
|
|
|
|
// Check whether the right hand side is the empty string (i.e. if
|
|
|
|
// this is really a flat string in a cons string). If that is not
|
|
|
|
// the case we flatten the string first.
|
|
|
|
Label if_rhsisempty(this), if_rhsisnotempty(this, Label::kDeferred);
|
|
|
|
Node* rhs = LoadObjectField(string, ConsString::kSecondOffset);
|
|
|
|
Branch(WordEqual(rhs, EmptyStringConstant()), &if_rhsisempty,
|
|
|
|
&if_rhsisnotempty);
|
|
|
|
|
|
|
|
Bind(&if_rhsisempty);
|
|
|
|
{
|
|
|
|
// Just operate on the left hand side of the {string}.
|
|
|
|
var_string.Bind(LoadObjectField(string, ConsString::kFirstOffset));
|
|
|
|
Goto(&loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_rhsisnotempty);
|
|
|
|
{
|
|
|
|
// Flatten the {string} and lookup in the resulting string.
|
|
|
|
var_string.Bind(CallRuntime(Runtime::kFlattenString,
|
|
|
|
NoContextConstant(), string));
|
|
|
|
Goto(&loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_stringisnotcons);
|
|
|
|
{
|
|
|
|
// Check if the {string} is an ExternalString.
|
|
|
|
Label if_stringisexternal(this), if_stringisnotexternal(this);
|
|
|
|
Branch(Word32Equal(Word32And(string_instance_type,
|
|
|
|
Int32Constant(kStringRepresentationMask)),
|
|
|
|
Int32Constant(kExternalStringTag)),
|
|
|
|
&if_stringisexternal, &if_stringisnotexternal);
|
|
|
|
|
|
|
|
Bind(&if_stringisexternal);
|
|
|
|
{
|
|
|
|
// Check if the {string} is a short external string.
|
|
|
|
Label if_stringisshort(this),
|
|
|
|
if_stringisnotshort(this, Label::kDeferred);
|
|
|
|
Branch(Word32Equal(Word32And(string_instance_type,
|
|
|
|
Int32Constant(kShortExternalStringMask)),
|
|
|
|
Int32Constant(0)),
|
|
|
|
&if_stringisshort, &if_stringisnotshort);
|
|
|
|
|
|
|
|
Bind(&if_stringisshort);
|
|
|
|
{
|
|
|
|
// Load the actual resource data from the {string}.
|
|
|
|
Node* string_resource_data =
|
|
|
|
LoadObjectField(string, ExternalString::kResourceDataOffset,
|
|
|
|
MachineType::Pointer());
|
|
|
|
|
|
|
|
// Check if the {string} is a TwoByteExternalString or a
|
|
|
|
// OneByteExternalString.
|
|
|
|
Label if_stringistwobyte(this), if_stringisonebyte(this);
|
|
|
|
Branch(Word32Equal(Word32And(string_instance_type,
|
|
|
|
Int32Constant(kStringEncodingMask)),
|
|
|
|
Int32Constant(kTwoByteStringTag)),
|
|
|
|
&if_stringistwobyte, &if_stringisonebyte);
|
|
|
|
|
|
|
|
Bind(&if_stringisonebyte);
|
|
|
|
{
|
|
|
|
var_result.Bind(
|
|
|
|
Load(MachineType::Uint8(), string_resource_data, index));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_stringistwobyte);
|
|
|
|
{
|
|
|
|
var_result.Bind(Load(MachineType::Uint16(), string_resource_data,
|
|
|
|
WordShl(index, IntPtrConstant(1))));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_stringisnotshort);
|
|
|
|
{
|
|
|
|
// The {string} might be compressed, call the runtime.
|
|
|
|
var_result.Bind(SmiToWord32(
|
|
|
|
CallRuntime(Runtime::kExternalStringGetChar,
|
|
|
|
NoContextConstant(), string, SmiTag(index))));
|
|
|
|
Goto(&done_loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_stringisnotexternal);
|
|
|
|
{
|
|
|
|
// The {string} is a SlicedString, continue with its parent.
|
|
|
|
Node* string_offset =
|
|
|
|
SmiToWord(LoadObjectField(string, SlicedString::kOffsetOffset));
|
|
|
|
Node* string_parent =
|
|
|
|
LoadObjectField(string, SlicedString::kParentOffset);
|
|
|
|
var_index.Bind(IntPtrAdd(index, string_offset));
|
|
|
|
var_string.Bind(string_parent);
|
|
|
|
Goto(&loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&done_loop);
|
|
|
|
return var_result.value();
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::StringFromCharCode(Node* code) {
|
|
|
|
Variable var_result(this, MachineRepresentation::kTagged);
|
|
|
|
|
|
|
|
// Check if the {code} is a one-byte char code.
|
|
|
|
Label if_codeisonebyte(this), if_codeistwobyte(this, Label::kDeferred),
|
|
|
|
if_done(this);
|
|
|
|
Branch(Int32LessThanOrEqual(code, Int32Constant(String::kMaxOneByteCharCode)),
|
|
|
|
&if_codeisonebyte, &if_codeistwobyte);
|
|
|
|
Bind(&if_codeisonebyte);
|
|
|
|
{
|
|
|
|
// Load the isolate wide single character string cache.
|
|
|
|
Node* cache = LoadRoot(Heap::kSingleCharacterStringCacheRootIndex);
|
|
|
|
|
|
|
|
// Check if we have an entry for the {code} in the single character string
|
|
|
|
// cache already.
|
|
|
|
Label if_entryisundefined(this, Label::kDeferred),
|
|
|
|
if_entryisnotundefined(this);
|
|
|
|
Node* entry = LoadFixedArrayElementInt32Index(cache, code);
|
|
|
|
Branch(WordEqual(entry, UndefinedConstant()), &if_entryisundefined,
|
|
|
|
&if_entryisnotundefined);
|
|
|
|
|
|
|
|
Bind(&if_entryisundefined);
|
|
|
|
{
|
|
|
|
// Allocate a new SeqOneByteString for {code} and store it in the {cache}.
|
|
|
|
Node* result = AllocateSeqOneByteString(1);
|
|
|
|
StoreNoWriteBarrier(
|
|
|
|
MachineRepresentation::kWord8, result,
|
|
|
|
IntPtrConstant(SeqOneByteString::kHeaderSize - kHeapObjectTag), code);
|
|
|
|
StoreFixedArrayElementInt32Index(cache, code, result);
|
|
|
|
var_result.Bind(result);
|
|
|
|
Goto(&if_done);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_entryisnotundefined);
|
|
|
|
{
|
|
|
|
// Return the entry from the {cache}.
|
|
|
|
var_result.Bind(entry);
|
|
|
|
Goto(&if_done);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_codeistwobyte);
|
|
|
|
{
|
|
|
|
// Allocate a new SeqTwoByteString for {code}.
|
|
|
|
Node* result = AllocateSeqTwoByteString(1);
|
|
|
|
StoreNoWriteBarrier(
|
|
|
|
MachineRepresentation::kWord16, result,
|
|
|
|
IntPtrConstant(SeqTwoByteString::kHeaderSize - kHeapObjectTag), code);
|
|
|
|
var_result.Bind(result);
|
|
|
|
Goto(&if_done);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bind(&if_done);
|
|
|
|
return var_result.value();
|
|
|
|
}
|
|
|
|
|
2016-04-13 18:21:30 +00:00
|
|
|
Node* CodeStubAssembler::TruncateFloat64ToInt32(Node* value) {
|
|
|
|
return raw_assembler_->TruncateFloat64ToInt32(TruncationMode::kJavaScript,
|
|
|
|
value);
|
|
|
|
}
|
|
|
|
|
2016-03-17 14:23:12 +00:00
|
|
|
void CodeStubAssembler::BranchIf(Node* condition, Label* if_true,
|
|
|
|
Label* if_false) {
|
2016-03-21 12:03:33 +00:00
|
|
|
Label if_condition_is_true(this), if_condition_is_false(this);
|
|
|
|
Branch(condition, &if_condition_is_true, &if_condition_is_false);
|
|
|
|
Bind(&if_condition_is_true);
|
2016-03-17 14:23:12 +00:00
|
|
|
Goto(if_true);
|
2016-03-21 12:03:33 +00:00
|
|
|
Bind(&if_condition_is_false);
|
2016-03-16 09:36:52 +00:00
|
|
|
Goto(if_false);
|
|
|
|
}
|
|
|
|
|
2015-12-02 12:35:12 +00:00
|
|
|
Node* CodeStubAssembler::CallN(CallDescriptor* descriptor, Node* code_target,
|
|
|
|
Node** args) {
|
2016-02-10 16:38:49 +00:00
|
|
|
CallPrologue();
|
|
|
|
Node* return_value = raw_assembler_->CallN(descriptor, code_target, args);
|
|
|
|
CallEpilogue();
|
|
|
|
return return_value;
|
2015-12-02 12:35:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::TailCallN(CallDescriptor* descriptor,
|
|
|
|
Node* code_target, Node** args) {
|
|
|
|
return raw_assembler_->TailCallN(descriptor, code_target, args);
|
|
|
|
}
|
|
|
|
|
2016-02-10 16:38:49 +00:00
|
|
|
Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context) {
|
|
|
|
CallPrologue();
|
|
|
|
Node* return_value = raw_assembler_->CallRuntime0(function_id, context);
|
|
|
|
CallEpilogue();
|
|
|
|
return return_value;
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1) {
|
2016-02-10 16:38:49 +00:00
|
|
|
CallPrologue();
|
|
|
|
Node* return_value = raw_assembler_->CallRuntime1(function_id, arg1, context);
|
|
|
|
CallEpilogue();
|
|
|
|
return return_value;
|
2015-12-02 12:35:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1, Node* arg2) {
|
2016-02-10 16:38:49 +00:00
|
|
|
CallPrologue();
|
|
|
|
Node* return_value =
|
|
|
|
raw_assembler_->CallRuntime2(function_id, arg1, arg2, context);
|
|
|
|
CallEpilogue();
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1, Node* arg2,
|
|
|
|
Node* arg3) {
|
|
|
|
CallPrologue();
|
|
|
|
Node* return_value =
|
|
|
|
raw_assembler_->CallRuntime3(function_id, arg1, arg2, arg3, context);
|
|
|
|
CallEpilogue();
|
|
|
|
return return_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1, Node* arg2,
|
|
|
|
Node* arg3, Node* arg4) {
|
|
|
|
CallPrologue();
|
|
|
|
Node* return_value = raw_assembler_->CallRuntime4(function_id, arg1, arg2,
|
|
|
|
arg3, arg4, context);
|
|
|
|
CallEpilogue();
|
|
|
|
return return_value;
|
2015-12-02 12:35:12 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 22:04:55 +00:00
|
|
|
Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context) {
|
|
|
|
return raw_assembler_->TailCallRuntime0(function_id, context);
|
|
|
|
}
|
|
|
|
|
2015-12-02 12:35:12 +00:00
|
|
|
Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1) {
|
|
|
|
return raw_assembler_->TailCallRuntime1(function_id, arg1, context);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1,
|
|
|
|
Node* arg2) {
|
|
|
|
return raw_assembler_->TailCallRuntime2(function_id, arg1, arg2, context);
|
|
|
|
}
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1, Node* arg2,
|
|
|
|
Node* arg3) {
|
|
|
|
return raw_assembler_->TailCallRuntime3(function_id, arg1, arg2, arg3,
|
|
|
|
context);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
|
|
|
|
Node* context, Node* arg1, Node* arg2,
|
|
|
|
Node* arg3, Node* arg4) {
|
|
|
|
return raw_assembler_->TailCallRuntime4(function_id, arg1, arg2, arg3, arg4,
|
|
|
|
context);
|
|
|
|
}
|
|
|
|
|
2016-03-03 16:38:55 +00:00
|
|
|
Node* CodeStubAssembler::CallStub(Callable const& callable, Node* context,
|
|
|
|
Node* arg1, size_t result_size) {
|
|
|
|
Node* target = HeapConstant(callable.code());
|
|
|
|
return CallStub(callable.descriptor(), target, context, arg1, result_size);
|
|
|
|
}
|
|
|
|
|
2016-04-06 08:37:09 +00:00
|
|
|
Node* CodeStubAssembler::CallStub(Callable const& callable, Node* context,
|
|
|
|
Node* arg1, Node* arg2, size_t result_size) {
|
|
|
|
Node* target = HeapConstant(callable.code());
|
|
|
|
return CallStub(callable.descriptor(), target, context, arg1, arg2,
|
|
|
|
result_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallStub(Callable const& callable, Node* context,
|
|
|
|
Node* arg1, Node* arg2, Node* arg3,
|
|
|
|
size_t result_size) {
|
|
|
|
Node* target = HeapConstant(callable.code());
|
|
|
|
return CallStub(callable.descriptor(), target, context, arg1, arg2, arg3,
|
|
|
|
result_size);
|
|
|
|
}
|
|
|
|
|
2016-02-10 16:38:49 +00:00
|
|
|
Node* CodeStubAssembler::CallStub(const CallInterfaceDescriptor& descriptor,
|
|
|
|
Node* target, Node* context, Node* arg1,
|
|
|
|
size_t result_size) {
|
|
|
|
CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
|
|
|
|
isolate(), zone(), descriptor, descriptor.GetStackParameterCount(),
|
|
|
|
CallDescriptor::kNoFlags, Operator::kNoProperties,
|
|
|
|
MachineType::AnyTagged(), result_size);
|
|
|
|
|
|
|
|
Node** args = zone()->NewArray<Node*>(2);
|
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = context;
|
|
|
|
|
|
|
|
return CallN(call_descriptor, target, args);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallStub(const CallInterfaceDescriptor& descriptor,
|
|
|
|
Node* target, Node* context, Node* arg1,
|
|
|
|
Node* arg2, size_t result_size) {
|
|
|
|
CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
|
|
|
|
isolate(), zone(), descriptor, descriptor.GetStackParameterCount(),
|
|
|
|
CallDescriptor::kNoFlags, Operator::kNoProperties,
|
|
|
|
MachineType::AnyTagged(), result_size);
|
|
|
|
|
|
|
|
Node** args = zone()->NewArray<Node*>(3);
|
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = arg2;
|
|
|
|
args[2] = context;
|
|
|
|
|
|
|
|
return CallN(call_descriptor, target, args);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallStub(const CallInterfaceDescriptor& descriptor,
|
|
|
|
Node* target, Node* context, Node* arg1,
|
|
|
|
Node* arg2, Node* arg3, size_t result_size) {
|
|
|
|
CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
|
|
|
|
isolate(), zone(), descriptor, descriptor.GetStackParameterCount(),
|
|
|
|
CallDescriptor::kNoFlags, Operator::kNoProperties,
|
|
|
|
MachineType::AnyTagged(), result_size);
|
|
|
|
|
|
|
|
Node** args = zone()->NewArray<Node*>(4);
|
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = arg2;
|
|
|
|
args[2] = arg3;
|
|
|
|
args[3] = context;
|
|
|
|
|
|
|
|
return CallN(call_descriptor, target, args);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallStub(const CallInterfaceDescriptor& descriptor,
|
|
|
|
Node* target, Node* context, Node* arg1,
|
|
|
|
Node* arg2, Node* arg3, Node* arg4,
|
|
|
|
size_t result_size) {
|
|
|
|
CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
|
|
|
|
isolate(), zone(), descriptor, descriptor.GetStackParameterCount(),
|
|
|
|
CallDescriptor::kNoFlags, Operator::kNoProperties,
|
|
|
|
MachineType::AnyTagged(), result_size);
|
|
|
|
|
|
|
|
Node** args = zone()->NewArray<Node*>(5);
|
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = arg2;
|
|
|
|
args[2] = arg3;
|
|
|
|
args[3] = arg4;
|
|
|
|
args[4] = context;
|
|
|
|
|
|
|
|
return CallN(call_descriptor, target, args);
|
|
|
|
}
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::CallStub(const CallInterfaceDescriptor& descriptor,
|
|
|
|
Node* target, Node* context, Node* arg1,
|
|
|
|
Node* arg2, Node* arg3, Node* arg4,
|
|
|
|
Node* arg5, size_t result_size) {
|
|
|
|
CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
|
|
|
|
isolate(), zone(), descriptor, descriptor.GetStackParameterCount(),
|
|
|
|
CallDescriptor::kNoFlags, Operator::kNoProperties,
|
|
|
|
MachineType::AnyTagged(), result_size);
|
|
|
|
|
|
|
|
Node** args = zone()->NewArray<Node*>(6);
|
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = arg2;
|
|
|
|
args[2] = arg3;
|
|
|
|
args[3] = arg4;
|
|
|
|
args[4] = arg5;
|
|
|
|
args[5] = context;
|
|
|
|
|
|
|
|
return CallN(call_descriptor, target, args);
|
|
|
|
}
|
|
|
|
|
2016-03-03 10:10:30 +00:00
|
|
|
Node* CodeStubAssembler::TailCallStub(Callable const& callable, Node* context,
|
|
|
|
Node* arg1, Node* arg2,
|
|
|
|
size_t result_size) {
|
|
|
|
Node* target = HeapConstant(callable.code());
|
|
|
|
return TailCallStub(callable.descriptor(), target, context, arg1, arg2,
|
|
|
|
result_size);
|
|
|
|
}
|
|
|
|
|
2016-03-02 11:46:57 +00:00
|
|
|
Node* CodeStubAssembler::TailCallStub(const CallInterfaceDescriptor& descriptor,
|
|
|
|
Node* target, Node* context, Node* arg1,
|
|
|
|
Node* arg2, size_t result_size) {
|
|
|
|
CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
|
|
|
|
isolate(), zone(), descriptor, descriptor.GetStackParameterCount(),
|
|
|
|
CallDescriptor::kSupportsTailCalls, Operator::kNoProperties,
|
|
|
|
MachineType::AnyTagged(), result_size);
|
|
|
|
|
|
|
|
Node** args = zone()->NewArray<Node*>(3);
|
|
|
|
args[0] = arg1;
|
|
|
|
args[1] = arg2;
|
|
|
|
args[2] = context;
|
|
|
|
|
|
|
|
return raw_assembler_->TailCallN(call_descriptor, target, args);
|
2016-02-02 09:42:13 +00:00
|
|
|
}
|
|
|
|
|
2016-04-14 10:03:48 +00:00
|
|
|
Node* CodeStubAssembler::TailCallBytecodeDispatch(
|
|
|
|
const CallInterfaceDescriptor& interface_descriptor,
|
|
|
|
Node* code_target_address, Node** args) {
|
|
|
|
CallDescriptor* descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
|
2016-02-02 09:42:13 +00:00
|
|
|
isolate(), zone(), interface_descriptor,
|
2016-04-14 10:03:48 +00:00
|
|
|
interface_descriptor.GetStackParameterCount());
|
|
|
|
return raw_assembler_->TailCallN(descriptor, code_target_address, args);
|
2016-02-02 09:42:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CodeStubAssembler::Goto(CodeStubAssembler::Label* label) {
|
|
|
|
label->MergeVariables();
|
|
|
|
raw_assembler_->Goto(label->label_);
|
|
|
|
}
|
|
|
|
|
2016-03-30 11:56:31 +00:00
|
|
|
void CodeStubAssembler::GotoIf(Node* condition, Label* true_label) {
|
|
|
|
Label false_label(this);
|
|
|
|
Branch(condition, true_label, &false_label);
|
|
|
|
Bind(&false_label);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeStubAssembler::GotoUnless(Node* condition, Label* false_label) {
|
|
|
|
Label true_label(this);
|
|
|
|
Branch(condition, &true_label, false_label);
|
|
|
|
Bind(&true_label);
|
|
|
|
}
|
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
void CodeStubAssembler::Branch(Node* condition,
|
|
|
|
CodeStubAssembler::Label* true_label,
|
|
|
|
CodeStubAssembler::Label* false_label) {
|
|
|
|
true_label->MergeVariables();
|
|
|
|
false_label->MergeVariables();
|
|
|
|
return raw_assembler_->Branch(condition, true_label->label_,
|
|
|
|
false_label->label_);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeStubAssembler::Switch(Node* index, Label* default_label,
|
|
|
|
int32_t* case_values, Label** case_labels,
|
|
|
|
size_t case_count) {
|
|
|
|
RawMachineLabel** labels =
|
|
|
|
new (zone()->New(sizeof(RawMachineLabel*) * case_count))
|
|
|
|
RawMachineLabel*[case_count];
|
|
|
|
for (size_t i = 0; i < case_count; ++i) {
|
|
|
|
labels[i] = case_labels[i]->label_;
|
|
|
|
case_labels[i]->MergeVariables();
|
|
|
|
default_label->MergeVariables();
|
|
|
|
}
|
|
|
|
return raw_assembler_->Switch(index, default_label->label_, case_values,
|
|
|
|
labels, case_count);
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
|
|
|
// RawMachineAssembler delegate helpers:
|
2016-03-02 11:46:57 +00:00
|
|
|
Isolate* CodeStubAssembler::isolate() const {
|
|
|
|
return raw_assembler_->isolate();
|
|
|
|
}
|
|
|
|
|
|
|
|
Factory* CodeStubAssembler::factory() const { return isolate()->factory(); }
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-03-02 11:46:57 +00:00
|
|
|
Graph* CodeStubAssembler::graph() const { return raw_assembler_->graph(); }
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-03-02 11:46:57 +00:00
|
|
|
Zone* CodeStubAssembler::zone() const { return raw_assembler_->zone(); }
|
2015-12-02 12:35:12 +00:00
|
|
|
|
2016-02-02 09:42:13 +00:00
|
|
|
// The core implementation of Variable is stored through an indirection so
|
|
|
|
// that it can outlive the often block-scoped Variable declarations. This is
|
|
|
|
// needed to ensure that variable binding and merging through phis can
|
|
|
|
// properly be verified.
|
|
|
|
class CodeStubAssembler::Variable::Impl : public ZoneObject {
|
|
|
|
public:
|
|
|
|
explicit Impl(MachineRepresentation rep) : value_(nullptr), rep_(rep) {}
|
|
|
|
Node* value_;
|
|
|
|
MachineRepresentation rep_;
|
|
|
|
};
|
|
|
|
|
|
|
|
CodeStubAssembler::Variable::Variable(CodeStubAssembler* assembler,
|
|
|
|
MachineRepresentation rep)
|
|
|
|
: impl_(new (assembler->zone()) Impl(rep)) {
|
|
|
|
assembler->variables_.push_back(impl_);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeStubAssembler::Variable::Bind(Node* value) { impl_->value_ = value; }
|
|
|
|
|
|
|
|
Node* CodeStubAssembler::Variable::value() const {
|
|
|
|
DCHECK_NOT_NULL(impl_->value_);
|
|
|
|
return impl_->value_;
|
|
|
|
}
|
|
|
|
|
|
|
|
MachineRepresentation CodeStubAssembler::Variable::rep() const {
|
|
|
|
return impl_->rep_;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CodeStubAssembler::Variable::IsBound() const {
|
|
|
|
return impl_->value_ != nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
CodeStubAssembler::Label::Label(CodeStubAssembler* assembler,
|
|
|
|
int merged_value_count,
|
2016-03-03 16:38:55 +00:00
|
|
|
CodeStubAssembler::Variable** merged_variables,
|
|
|
|
CodeStubAssembler::Label::Type type)
|
2016-02-02 09:42:13 +00:00
|
|
|
: bound_(false), merge_count_(0), assembler_(assembler), label_(nullptr) {
|
|
|
|
void* buffer = assembler->zone()->New(sizeof(RawMachineLabel));
|
2016-03-03 16:38:55 +00:00
|
|
|
label_ = new (buffer)
|
|
|
|
RawMachineLabel(type == kDeferred ? RawMachineLabel::kDeferred
|
|
|
|
: RawMachineLabel::kNonDeferred);
|
2016-02-02 09:42:13 +00:00
|
|
|
for (int i = 0; i < merged_value_count; ++i) {
|
|
|
|
variable_phis_[merged_variables[i]->impl_] = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeStubAssembler::Label::MergeVariables() {
|
|
|
|
++merge_count_;
|
|
|
|
for (auto var : assembler_->variables_) {
|
|
|
|
size_t count = 0;
|
|
|
|
Node* node = var->value_;
|
|
|
|
if (node != nullptr) {
|
|
|
|
auto i = variable_merges_.find(var);
|
|
|
|
if (i != variable_merges_.end()) {
|
|
|
|
i->second.push_back(node);
|
|
|
|
count = i->second.size();
|
|
|
|
} else {
|
|
|
|
count = 1;
|
|
|
|
variable_merges_[var] = std::vector<Node*>(1, node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// If the following asserts, then you've jumped to a label without a bound
|
|
|
|
// variable along that path that expects to merge its value into a phi.
|
|
|
|
DCHECK(variable_phis_.find(var) == variable_phis_.end() ||
|
|
|
|
count == merge_count_);
|
|
|
|
USE(count);
|
|
|
|
|
|
|
|
// If the label is already bound, we already know the set of variables to
|
|
|
|
// merge and phi nodes have already been created.
|
|
|
|
if (bound_) {
|
|
|
|
auto phi = variable_phis_.find(var);
|
|
|
|
if (phi != variable_phis_.end()) {
|
|
|
|
DCHECK_NOT_NULL(phi->second);
|
|
|
|
assembler_->raw_assembler_->AppendPhiInput(phi->second, node);
|
|
|
|
} else {
|
|
|
|
auto i = variable_merges_.find(var);
|
2016-03-03 16:38:55 +00:00
|
|
|
if (i != variable_merges_.end()) {
|
|
|
|
// If the following assert fires, then you've declared a variable that
|
|
|
|
// has the same bound value along all paths up until the point you
|
|
|
|
// bound this label, but then later merged a path with a new value for
|
|
|
|
// the variable after the label bind (it's not possible to add phis to
|
|
|
|
// the bound label after the fact, just make sure to list the variable
|
|
|
|
// in the label's constructor's list of merged variables).
|
|
|
|
DCHECK(find_if(i->second.begin(), i->second.end(),
|
|
|
|
[node](Node* e) -> bool { return node != e; }) ==
|
|
|
|
i->second.end());
|
|
|
|
}
|
2016-02-02 09:42:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeStubAssembler::Label::Bind() {
|
|
|
|
DCHECK(!bound_);
|
|
|
|
assembler_->raw_assembler_->Bind(label_);
|
|
|
|
|
|
|
|
// Make sure that all variables that have changed along any path up to this
|
|
|
|
// point are marked as merge variables.
|
|
|
|
for (auto var : assembler_->variables_) {
|
|
|
|
Node* shared_value = nullptr;
|
|
|
|
auto i = variable_merges_.find(var);
|
|
|
|
if (i != variable_merges_.end()) {
|
|
|
|
for (auto value : i->second) {
|
|
|
|
DCHECK(value != nullptr);
|
|
|
|
if (value != shared_value) {
|
|
|
|
if (shared_value == nullptr) {
|
|
|
|
shared_value = value;
|
|
|
|
} else {
|
|
|
|
variable_phis_[var] = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto var : variable_phis_) {
|
|
|
|
CodeStubAssembler::Variable::Impl* var_impl = var.first;
|
|
|
|
auto i = variable_merges_.find(var_impl);
|
|
|
|
// If the following assert fires, then a variable that has been marked as
|
|
|
|
// being merged at the label--either by explicitly marking it so in the
|
|
|
|
// label constructor or by having seen different bound values at branches
|
|
|
|
// into the label--doesn't have a bound value along all of the paths that
|
|
|
|
// have been merged into the label up to this point.
|
|
|
|
DCHECK(i != variable_merges_.end() && i->second.size() == merge_count_);
|
|
|
|
Node* phi = assembler_->raw_assembler_->Phi(
|
|
|
|
var.first->rep_, static_cast<int>(merge_count_), &(i->second[0]));
|
|
|
|
variable_phis_[var_impl] = phi;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bind all variables to a merge phi, the common value along all paths or
|
|
|
|
// null.
|
|
|
|
for (auto var : assembler_->variables_) {
|
|
|
|
auto i = variable_phis_.find(var);
|
|
|
|
if (i != variable_phis_.end()) {
|
|
|
|
var->value_ = i->second;
|
|
|
|
} else {
|
|
|
|
auto j = variable_merges_.find(var);
|
|
|
|
if (j != variable_merges_.end() && j->second.size() == merge_count_) {
|
|
|
|
var->value_ = j->second.back();
|
|
|
|
} else {
|
|
|
|
var->value_ = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bound_ = true;
|
|
|
|
}
|
2015-12-02 12:35:12 +00:00
|
|
|
|
|
|
|
} // namespace compiler
|
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|