zra@google.com
632e9c7aaf
Also re-enables a stack frame test that was disabled in checked mode. Review URL: https://codereview.chromium.org//14431004 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@21951 260f80e4-7a28-3924-810f-c04153c831b5
2443 lines
76 KiB
C++
2443 lines
76 KiB
C++
// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#include "vm/globals.h" // Needed here to get TARGET_ARCH_MIPS.
|
|
#if defined(TARGET_ARCH_MIPS)
|
|
|
|
#include "vm/intermediate_language.h"
|
|
|
|
#include "lib/error.h"
|
|
#include "vm/dart_entry.h"
|
|
#include "vm/flow_graph_compiler.h"
|
|
#include "vm/locations.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/parser.h"
|
|
#include "vm/simulator.h"
|
|
#include "vm/stub_code.h"
|
|
#include "vm/symbols.h"
|
|
|
|
#define __ compiler->assembler()->
|
|
|
|
namespace dart {
|
|
|
|
DECLARE_FLAG(int, optimization_counter_threshold);
|
|
DECLARE_FLAG(bool, propagate_ic_data);
|
|
|
|
// Generic summary for call instructions that have all arguments pushed
|
|
// on the stack and return the result in a fixed register V0.
|
|
LocationSummary* Instruction::MakeCallSummary() {
|
|
LocationSummary* result = new LocationSummary(0, 0, LocationSummary::kCall);
|
|
result->set_out(Location::RegisterLocation(V0));
|
|
return result;
|
|
}
|
|
|
|
|
|
LocationSummary* PushArgumentInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps= 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::AnyOrConstant(value()));
|
|
return locs;
|
|
}
|
|
|
|
|
|
void PushArgumentInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
// In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
|
|
// where PushArgument is handled by BindInstr::EmitNativeCode.
|
|
__ TraceSimMsg("PushArgumentInstr");
|
|
if (compiler->is_optimizing()) {
|
|
Location value = locs()->in(0);
|
|
if (value.IsRegister()) {
|
|
__ Push(value.reg());
|
|
} else if (value.IsConstant()) {
|
|
__ PushObject(value.constant());
|
|
} else {
|
|
ASSERT(value.IsStackSlot());
|
|
__ lw(TMP, value.ToStackSlotAddress());
|
|
__ Push(TMP);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
LocationSummary* ReturnInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RegisterLocation(V0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
// Attempt optimized compilation at return instruction instead of at the entry.
|
|
// The entry needs to be patchable, no inlined objects are allowed in the area
|
|
// that will be overwritten by the patch instructions: a branch macro sequence.
|
|
void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("ReturnInstr");
|
|
Register result = locs()->in(0).reg();
|
|
ASSERT(result == V0);
|
|
#if defined(DEBUG)
|
|
// TODO(srdjan): Fix for functions with finally clause.
|
|
// A finally clause may leave a previously pushed return value if it
|
|
// has its own return instruction. Method that have finally are currently
|
|
// not optimized.
|
|
if (!compiler->HasFinally()) {
|
|
Label stack_ok;
|
|
__ Comment("Stack Check");
|
|
__ TraceSimMsg("Stack Check");
|
|
const intptr_t fp_sp_dist =
|
|
(kFirstLocalSlotIndex + 1 - compiler->StackSize()) * kWordSize;
|
|
ASSERT(fp_sp_dist <= 0);
|
|
__ subu(T2, SP, FP);
|
|
|
|
__ BranchEqual(T2, fp_sp_dist, &stack_ok);
|
|
__ break_(0);
|
|
|
|
__ Bind(&stack_ok);
|
|
}
|
|
#endif
|
|
__ LeaveDartFrame();
|
|
__ Ret();
|
|
|
|
// Generate 2 NOP instructions so that the debugger can patch the return
|
|
// pattern (1 instruction) with a call to the debug stub (3 instructions).
|
|
__ nop();
|
|
__ nop();
|
|
compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
|
|
Isolate::kNoDeoptId,
|
|
token_pos());
|
|
}
|
|
|
|
|
|
bool IfThenElseInstr::IsSupported() {
|
|
return false;
|
|
}
|
|
|
|
|
|
bool IfThenElseInstr::Supports(ComparisonInstr* comparison,
|
|
Value* v1,
|
|
Value* v2) {
|
|
UNREACHABLE();
|
|
return false;
|
|
}
|
|
|
|
|
|
LocationSummary* IfThenElseInstr::MakeLocationSummary() const {
|
|
UNREACHABLE();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void IfThenElseInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNREACHABLE();
|
|
}
|
|
|
|
|
|
LocationSummary* ClosureCallInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 0;
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* result =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
result->set_out(Location::RegisterLocation(V0));
|
|
result->set_temp(0, Location::RegisterLocation(S4)); // Arg. descriptor.
|
|
return result;
|
|
}
|
|
|
|
|
|
void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
// The arguments to the stub include the closure, as does the arguments
|
|
// descriptor.
|
|
Register temp_reg = locs()->temp(0).reg();
|
|
int argument_count = ArgumentCount();
|
|
const Array& arguments_descriptor =
|
|
Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
|
|
argument_names()));
|
|
__ LoadObject(temp_reg, arguments_descriptor);
|
|
compiler->GenerateDartCall(deopt_id(),
|
|
token_pos(),
|
|
&StubCode::CallClosureFunctionLabel(),
|
|
PcDescriptors::kOther,
|
|
locs());
|
|
__ Drop(argument_count);
|
|
}
|
|
|
|
|
|
LocationSummary* LoadLocalInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(0,
|
|
Location::RequiresRegister(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void LoadLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("LoadLocalInstr");
|
|
Register result = locs()->out().reg();
|
|
__ lw(result, Address(FP, local().index() * kWordSize));
|
|
}
|
|
|
|
|
|
LocationSummary* StoreLocalInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(1,
|
|
Location::SameAsFirstInput(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void StoreLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("StoreLocalInstr");
|
|
Register value = locs()->in(0).reg();
|
|
Register result = locs()->out().reg();
|
|
ASSERT(result == value); // Assert that register assignment is correct.
|
|
__ sw(value, Address(FP, local().index() * kWordSize));
|
|
}
|
|
|
|
|
|
LocationSummary* ConstantInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(0,
|
|
Location::RequiresRegister(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
// The register allocator drops constant definitions that have no uses.
|
|
if (!locs()->out().IsInvalid()) {
|
|
__ TraceSimMsg("ConstantInstr");
|
|
Register result = locs()->out().reg();
|
|
__ LoadObject(result, value());
|
|
}
|
|
}
|
|
|
|
|
|
LocationSummary* AssertAssignableInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 3;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
summary->set_in(0, Location::RegisterLocation(A0)); // Value.
|
|
summary->set_in(1, Location::RegisterLocation(A2)); // Instantiator.
|
|
summary->set_in(2, Location::RegisterLocation(A1)); // Type arguments.
|
|
summary->set_out(Location::RegisterLocation(A0));
|
|
return summary;
|
|
}
|
|
|
|
|
|
LocationSummary* AssertBooleanInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
locs->set_in(0, Location::RegisterLocation(A0));
|
|
locs->set_out(Location::RegisterLocation(A0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
static void EmitAssertBoolean(Register reg,
|
|
intptr_t token_pos,
|
|
intptr_t deopt_id,
|
|
LocationSummary* locs,
|
|
FlowGraphCompiler* compiler) {
|
|
// Check that the type of the value is allowed in conditional context.
|
|
// Call the runtime if the object is not bool::true or bool::false.
|
|
ASSERT(locs->always_calls());
|
|
Label done;
|
|
__ BranchEqual(reg, Bool::True(), &done);
|
|
__ BranchEqual(reg, Bool::False(), &done);
|
|
|
|
__ Push(reg); // Push the source object.
|
|
compiler->GenerateCallRuntime(token_pos,
|
|
deopt_id,
|
|
kConditionTypeErrorRuntimeEntry,
|
|
locs);
|
|
// We should never return here.
|
|
__ break_(0);
|
|
__ Bind(&done);
|
|
}
|
|
|
|
|
|
void AssertBooleanInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
Register obj = locs()->in(0).reg();
|
|
Register result = locs()->out().reg();
|
|
|
|
__ TraceSimMsg("AssertBooleanInstr");
|
|
EmitAssertBoolean(obj, token_pos(), deopt_id(), locs(), compiler);
|
|
ASSERT(obj == result);
|
|
}
|
|
|
|
|
|
LocationSummary* ArgumentDefinitionTestInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void ArgumentDefinitionTestInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* EqualityCompareInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 2;
|
|
const bool is_checked_strict_equal =
|
|
HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
|
|
if (receiver_class_id() == kMintCid) {
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RequiresFpuRegister());
|
|
locs->set_in(1, Location::RequiresFpuRegister());
|
|
locs->set_temp(0, Location::RequiresRegister());
|
|
locs->set_out(Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
if (receiver_class_id() == kDoubleCid) {
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RequiresFpuRegister());
|
|
locs->set_in(1, Location::RequiresFpuRegister());
|
|
locs->set_out(Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
if (receiver_class_id() == kSmiCid) {
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RegisterOrConstant(left()));
|
|
// Only one input can be a constant operand. The case of two constant
|
|
// operands should be handled by constant propagation.
|
|
locs->set_in(1, locs->in(0).IsConstant()
|
|
? Location::RequiresRegister()
|
|
: Location::RegisterOrConstant(right()));
|
|
locs->set_out(Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
if (is_checked_strict_equal) {
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RequiresRegister());
|
|
locs->set_in(1, Location::RequiresRegister());
|
|
locs->set_temp(0, Location::RequiresRegister());
|
|
locs->set_out(Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
if (IsPolymorphic()) {
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
UNIMPLEMENTED(); // TODO(regis): Verify register allocation.
|
|
return locs;
|
|
}
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
locs->set_in(0, Location::RegisterLocation(A1));
|
|
locs->set_in(1, Location::RegisterLocation(A0));
|
|
locs->set_temp(0, Location::RegisterLocation(T0));
|
|
locs->set_out(Location::RegisterLocation(V0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
// A1: left.
|
|
// A0: right.
|
|
// Uses T0 to load ic_call_data.
|
|
// Result in V0.
|
|
static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
|
|
intptr_t deopt_id,
|
|
intptr_t token_pos,
|
|
Token::Kind kind,
|
|
LocationSummary* locs,
|
|
const ICData& original_ic_data) {
|
|
__ TraceSimMsg("EmitEqualityAsInstanceCall");
|
|
if (!compiler->is_optimizing()) {
|
|
compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
|
|
deopt_id,
|
|
token_pos);
|
|
}
|
|
const int kNumberOfArguments = 2;
|
|
const Array& kNoArgumentNames = Array::Handle();
|
|
const int kNumArgumentsChecked = 2;
|
|
|
|
Label check_identity;
|
|
__ LoadImmediate(TMP1, reinterpret_cast<intptr_t>(Object::null()));
|
|
__ beq(A1, TMP1, &check_identity);
|
|
__ beq(A0, TMP1, &check_identity);
|
|
|
|
ICData& equality_ic_data = ICData::ZoneHandle();
|
|
if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
|
|
ASSERT(!original_ic_data.IsNull());
|
|
if (original_ic_data.NumberOfChecks() == 0) {
|
|
// IC call for reoptimization populates original ICData.
|
|
equality_ic_data = original_ic_data.raw();
|
|
} else {
|
|
// Megamorphic call.
|
|
equality_ic_data = original_ic_data.AsUnaryClassChecks();
|
|
}
|
|
} else {
|
|
equality_ic_data = ICData::New(compiler->parsed_function().function(),
|
|
Symbols::EqualOperator(),
|
|
deopt_id,
|
|
kNumArgumentsChecked);
|
|
}
|
|
__ addiu(SP, SP, Immediate(-2 * kWordSize));
|
|
__ sw(A1, Address(SP, 1 * kWordSize));
|
|
__ sw(A0, Address(SP, 0 * kWordSize));
|
|
compiler->GenerateInstanceCall(deopt_id,
|
|
token_pos,
|
|
kNumberOfArguments,
|
|
kNoArgumentNames,
|
|
locs,
|
|
equality_ic_data);
|
|
Label check_ne;
|
|
__ b(&check_ne);
|
|
|
|
__ Bind(&check_identity);
|
|
Label equality_done;
|
|
if (compiler->is_optimizing()) {
|
|
// No need to update IC data.
|
|
Label is_true;
|
|
__ beq(A1, A0, &is_true);
|
|
__ LoadObject(V0, (kind == Token::kEQ) ? Bool::False() : Bool::True());
|
|
__ b(&equality_done);
|
|
__ Bind(&is_true);
|
|
__ LoadObject(V0, (kind == Token::kEQ) ? Bool::True() : Bool::False());
|
|
if (kind == Token::kNE) {
|
|
// Skip not-equal result conversion.
|
|
__ b(&equality_done);
|
|
}
|
|
} else {
|
|
// Call stub, load IC data in register. The stub will update ICData if
|
|
// necessary.
|
|
Register ic_data_reg = locs->temp(0).reg();
|
|
ASSERT(ic_data_reg == T0); // Stub depends on it.
|
|
__ LoadObject(ic_data_reg, equality_ic_data);
|
|
// Pass left in A1 and right in A0.
|
|
compiler->GenerateCall(token_pos,
|
|
&StubCode::EqualityWithNullArgLabel(),
|
|
PcDescriptors::kOther,
|
|
locs);
|
|
}
|
|
__ Bind(&check_ne);
|
|
if (kind == Token::kNE) {
|
|
Label true_label, done;
|
|
// Negate the condition: true label returns false and vice versa.
|
|
__ BranchEqual(V0, Bool::True(), &true_label);
|
|
__ LoadObject(V0, Bool::True());
|
|
__ b(&done);
|
|
__ Bind(&true_label);
|
|
__ LoadObject(V0, Bool::False());
|
|
__ Bind(&done);
|
|
}
|
|
__ Bind(&equality_done);
|
|
}
|
|
|
|
|
|
static void LoadValueCid(FlowGraphCompiler* compiler,
|
|
Register value_cid_reg,
|
|
Register value_reg,
|
|
Label* value_is_smi = NULL) {
|
|
__ TraceSimMsg("LoadValueCid");
|
|
Label done;
|
|
if (value_is_smi == NULL) {
|
|
__ LoadImmediate(value_cid_reg, kSmiCid);
|
|
}
|
|
__ andi(TMP1, value_reg, Immediate(kSmiTagMask));
|
|
if (value_is_smi == NULL) {
|
|
__ beq(TMP1, ZR, &done);
|
|
} else {
|
|
__ beq(TMP1, ZR, value_is_smi);
|
|
}
|
|
__ LoadClassId(value_cid_reg, value_reg);
|
|
__ Bind(&done);
|
|
}
|
|
|
|
|
|
// Emit code when ICData's targets are all Object == (which is ===).
|
|
static void EmitCheckedStrictEqual(FlowGraphCompiler* compiler,
|
|
const ICData& ic_data,
|
|
const LocationSummary& locs,
|
|
Token::Kind kind,
|
|
BranchInstr* branch,
|
|
intptr_t deopt_id) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
// First test if receiver is NULL, in which case === is applied.
|
|
// If type feedback was provided (lists of <class-id, target>), do a
|
|
// type by type check (either === or static call to the operator.
|
|
static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
|
|
LocationSummary* locs,
|
|
Token::Kind kind,
|
|
BranchInstr* branch,
|
|
const ICData& ic_data,
|
|
intptr_t deopt_id,
|
|
intptr_t token_pos) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
static Condition TokenKindToSmiCondition(Token::Kind kind) {
|
|
switch (kind) {
|
|
case Token::kEQ: return EQ;
|
|
case Token::kNE: return NE;
|
|
case Token::kLT: return LT;
|
|
case Token::kGT: return GT;
|
|
case Token::kLTE: return LE;
|
|
case Token::kGTE: return GE;
|
|
default:
|
|
UNREACHABLE();
|
|
return VS;
|
|
}
|
|
}
|
|
|
|
|
|
static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
|
|
const LocationSummary& locs,
|
|
Token::Kind kind,
|
|
BranchInstr* branch) {
|
|
__ TraceSimMsg("EmitSmiComparisonOp");
|
|
Location left = locs.in(0);
|
|
Location right = locs.in(1);
|
|
ASSERT(!left.IsConstant() || !right.IsConstant());
|
|
|
|
Condition true_condition = TokenKindToSmiCondition(kind);
|
|
|
|
if (left.IsConstant()) {
|
|
__ CompareObject(CMPRES, right.reg(), left.constant());
|
|
true_condition = FlowGraphCompiler::FlipCondition(true_condition);
|
|
} else if (right.IsConstant()) {
|
|
__ CompareObject(CMPRES, left.reg(), right.constant());
|
|
} else {
|
|
__ subu(CMPRES, left.reg(), right.reg());
|
|
}
|
|
|
|
if (branch != NULL) {
|
|
branch->EmitBranchOnCondition(compiler, true_condition);
|
|
} else {
|
|
Register result = locs.out().reg();
|
|
Label done, is_true;
|
|
switch (true_condition) {
|
|
case EQ: __ beq(CMPRES, ZR, &is_true); break;
|
|
case NE: __ bne(CMPRES, ZR, &is_true); break;
|
|
case GT: __ bgtz(CMPRES, &is_true); break;
|
|
case GE: __ bgez(CMPRES, &is_true); break;
|
|
case LT: __ bltz(CMPRES, &is_true); break;
|
|
case LE: __ blez(CMPRES, &is_true); break;
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
__ LoadObject(result, Bool::False());
|
|
__ b(&done);
|
|
__ Bind(&is_true);
|
|
__ LoadObject(result, Bool::True());
|
|
__ Bind(&done);
|
|
}
|
|
}
|
|
|
|
|
|
static void EmitUnboxedMintEqualityOp(FlowGraphCompiler* compiler,
|
|
const LocationSummary& locs,
|
|
Token::Kind kind,
|
|
BranchInstr* branch) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
static void EmitUnboxedMintComparisonOp(FlowGraphCompiler* compiler,
|
|
const LocationSummary& locs,
|
|
Token::Kind kind,
|
|
BranchInstr* branch) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
static void EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
|
|
const LocationSummary& locs,
|
|
Token::Kind kind,
|
|
BranchInstr* branch) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
void EqualityCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
|
|
BranchInstr* kNoBranch = NULL;
|
|
if (receiver_class_id() == kSmiCid) {
|
|
EmitSmiComparisonOp(compiler, *locs(), kind(), kNoBranch);
|
|
return;
|
|
}
|
|
if (receiver_class_id() == kMintCid) {
|
|
EmitUnboxedMintEqualityOp(compiler, *locs(), kind(), kNoBranch);
|
|
return;
|
|
}
|
|
if (receiver_class_id() == kDoubleCid) {
|
|
EmitDoubleComparisonOp(compiler, *locs(), kind(), kNoBranch);
|
|
return;
|
|
}
|
|
const bool is_checked_strict_equal =
|
|
HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
|
|
if (is_checked_strict_equal) {
|
|
EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), kNoBranch,
|
|
deopt_id());
|
|
return;
|
|
}
|
|
if (IsPolymorphic()) {
|
|
EmitGenericEqualityCompare(compiler, locs(), kind(), kNoBranch, *ic_data(),
|
|
deopt_id(), token_pos());
|
|
return;
|
|
}
|
|
Register left = locs()->in(0).reg();
|
|
Register right = locs()->in(1).reg();
|
|
ASSERT(left == A1);
|
|
ASSERT(right == A0);
|
|
EmitEqualityAsInstanceCall(compiler,
|
|
deopt_id(),
|
|
token_pos(),
|
|
kind(),
|
|
locs(),
|
|
*ic_data());
|
|
ASSERT(locs()->out().reg() == V0);
|
|
}
|
|
|
|
|
|
void EqualityCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
|
|
BranchInstr* branch) {
|
|
__ TraceSimMsg("EqualityCompareInstr");
|
|
ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
|
|
if (receiver_class_id() == kSmiCid) {
|
|
// Deoptimizes if both arguments not Smi.
|
|
EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
|
|
return;
|
|
}
|
|
if (receiver_class_id() == kMintCid) {
|
|
EmitUnboxedMintEqualityOp(compiler, *locs(), kind(), branch);
|
|
return;
|
|
}
|
|
if (receiver_class_id() == kDoubleCid) {
|
|
EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
|
|
return;
|
|
}
|
|
const bool is_checked_strict_equal =
|
|
HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
|
|
if (is_checked_strict_equal) {
|
|
EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), branch,
|
|
deopt_id());
|
|
return;
|
|
}
|
|
if (IsPolymorphic()) {
|
|
EmitGenericEqualityCompare(compiler, locs(), kind(), branch, *ic_data(),
|
|
deopt_id(), token_pos());
|
|
return;
|
|
}
|
|
Register left = locs()->in(0).reg();
|
|
Register right = locs()->in(1).reg();
|
|
ASSERT(left == A1);
|
|
ASSERT(right == A0);
|
|
EmitEqualityAsInstanceCall(compiler,
|
|
deopt_id(),
|
|
token_pos(),
|
|
Token::kEQ, // kNE reverse occurs at branch.
|
|
locs(),
|
|
*ic_data());
|
|
if (branch->is_checked()) {
|
|
EmitAssertBoolean(V0, token_pos(), deopt_id(), locs(), compiler);
|
|
}
|
|
Condition branch_condition = (kind() == Token::kNE) ? NE : EQ;
|
|
__ CompareObject(CMPRES, V0, Bool::True());
|
|
branch->EmitBranchOnCondition(compiler, branch_condition);
|
|
}
|
|
|
|
|
|
LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 2;
|
|
const intptr_t kNumTemps = 0;
|
|
if (operands_class_id() == kMintCid) {
|
|
const intptr_t kNumTemps = 2;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RequiresFpuRegister());
|
|
locs->set_in(1, Location::RequiresFpuRegister());
|
|
locs->set_temp(0, Location::RequiresRegister());
|
|
locs->set_temp(1, Location::RequiresRegister());
|
|
locs->set_out(Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
if (operands_class_id() == kDoubleCid) {
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
summary->set_in(0, Location::RequiresFpuRegister());
|
|
summary->set_in(1, Location::RequiresFpuRegister());
|
|
summary->set_out(Location::RequiresRegister());
|
|
return summary;
|
|
} else if (operands_class_id() == kSmiCid) {
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
summary->set_in(0, Location::RegisterOrConstant(left()));
|
|
// Only one input can be a constant operand. The case of two constant
|
|
// operands should be handled by constant propagation.
|
|
summary->set_in(1, summary->in(0).IsConstant()
|
|
? Location::RequiresRegister()
|
|
: Location::RegisterOrConstant(right()));
|
|
summary->set_out(Location::RequiresRegister());
|
|
return summary;
|
|
}
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
// Pick arbitrary fixed input registers because this is a call.
|
|
locs->set_in(0, Location::RegisterLocation(A0));
|
|
locs->set_in(1, Location::RegisterLocation(A1));
|
|
locs->set_out(Location::RegisterLocation(V0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("RelationalOpInstr");
|
|
if (operands_class_id() == kSmiCid) {
|
|
EmitSmiComparisonOp(compiler, *locs(), kind(), NULL);
|
|
return;
|
|
}
|
|
if (operands_class_id() == kMintCid) {
|
|
EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), NULL);
|
|
return;
|
|
}
|
|
if (operands_class_id() == kDoubleCid) {
|
|
EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL);
|
|
return;
|
|
}
|
|
|
|
// Push arguments for the call.
|
|
// TODO(fschneider): Split this instruction into different types to avoid
|
|
// explicitly pushing arguments to the call here.
|
|
Register left = locs()->in(0).reg();
|
|
Register right = locs()->in(1).reg();
|
|
__ addiu(SP, SP, Immediate(-2 * kWordSize));
|
|
__ sw(left, Address(SP, 1 * kWordSize));
|
|
__ sw(right, Address(SP, 0 * kWordSize));
|
|
if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
|
|
Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptRelationalOp);
|
|
// Load class into A2.
|
|
const intptr_t kNumArguments = 2;
|
|
LoadValueCid(compiler, A2, left);
|
|
compiler->EmitTestAndCall(ICData::Handle(ic_data()->AsUnaryClassChecks()),
|
|
A2, // Class id register.
|
|
kNumArguments,
|
|
Array::Handle(), // No named arguments.
|
|
deopt, // Deoptimize target.
|
|
deopt_id(),
|
|
token_pos(),
|
|
locs());
|
|
return;
|
|
}
|
|
const String& function_name =
|
|
String::ZoneHandle(Symbols::New(Token::Str(kind())));
|
|
if (!compiler->is_optimizing()) {
|
|
compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
|
|
deopt_id(),
|
|
token_pos());
|
|
}
|
|
const intptr_t kNumArguments = 2;
|
|
const intptr_t kNumArgsChecked = 2; // Type-feedback.
|
|
ICData& relational_ic_data = ICData::ZoneHandle(ic_data()->raw());
|
|
if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
|
|
ASSERT(!ic_data()->IsNull());
|
|
if (ic_data()->NumberOfChecks() == 0) {
|
|
// IC call for reoptimization populates original ICData.
|
|
relational_ic_data = ic_data()->raw();
|
|
} else {
|
|
// Megamorphic call.
|
|
relational_ic_data = ic_data()->AsUnaryClassChecks();
|
|
}
|
|
} else {
|
|
relational_ic_data = ICData::New(compiler->parsed_function().function(),
|
|
function_name,
|
|
deopt_id(),
|
|
kNumArgsChecked);
|
|
}
|
|
compiler->GenerateInstanceCall(deopt_id(),
|
|
token_pos(),
|
|
kNumArguments,
|
|
Array::ZoneHandle(), // No optional arguments.
|
|
locs(),
|
|
relational_ic_data);
|
|
}
|
|
|
|
|
|
void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
|
|
BranchInstr* branch) {
|
|
__ TraceSimMsg("RelationalOpInstr");
|
|
if (operands_class_id() == kSmiCid) {
|
|
EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
|
|
return;
|
|
}
|
|
if (operands_class_id() == kMintCid) {
|
|
EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), branch);
|
|
return;
|
|
}
|
|
if (operands_class_id() == kDoubleCid) {
|
|
EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
|
|
return;
|
|
}
|
|
EmitNativeCode(compiler);
|
|
__ CompareObject(CMPRES, V0, Bool::True());
|
|
branch->EmitBranchOnCondition(compiler, EQ);
|
|
}
|
|
|
|
|
|
LocationSummary* NativeCallInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 0;
|
|
const intptr_t kNumTemps = 3;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
locs->set_temp(0, Location::RegisterLocation(A1));
|
|
locs->set_temp(1, Location::RegisterLocation(A2));
|
|
locs->set_temp(2, Location::RegisterLocation(T5));
|
|
locs->set_out(Location::RegisterLocation(V0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("NativeCallInstr");
|
|
ASSERT(locs()->temp(0).reg() == A1);
|
|
ASSERT(locs()->temp(1).reg() == A2);
|
|
ASSERT(locs()->temp(2).reg() == T5);
|
|
Register result = locs()->out().reg();
|
|
|
|
// Push the result place holder initialized to NULL.
|
|
__ PushObject(Object::ZoneHandle());
|
|
// Pass a pointer to the first argument in A2.
|
|
if (!function().HasOptionalParameters()) {
|
|
__ AddImmediate(A2, FP, (kLastParamSlotIndex +
|
|
function().NumParameters() - 1) * kWordSize);
|
|
} else {
|
|
__ AddImmediate(A2, FP, kFirstLocalSlotIndex * kWordSize);
|
|
}
|
|
// Compute the effective address. When running under the simulator,
|
|
// this is a redirection address that forces the simulator to call
|
|
// into the runtime system.
|
|
uword entry = reinterpret_cast<uword>(native_c_function());
|
|
#if defined(USING_SIMULATOR)
|
|
entry = Simulator::RedirectExternalReference(entry, Simulator::kNativeCall);
|
|
#endif
|
|
__ LoadImmediate(T5, entry);
|
|
__ LoadImmediate(A1, NativeArguments::ComputeArgcTag(function()));
|
|
compiler->GenerateCall(token_pos(),
|
|
&StubCode::CallNativeCFunctionLabel(),
|
|
PcDescriptors::kOther,
|
|
locs());
|
|
__ Pop(result);
|
|
}
|
|
|
|
|
|
LocationSummary* StringFromCharCodeInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* LoadUntaggedInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void LoadUntaggedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
CompileType LoadIndexedInstr::ComputeType() const {
|
|
UNIMPLEMENTED();
|
|
return CompileType::Dynamic();
|
|
}
|
|
|
|
|
|
Representation LoadIndexedInstr::representation() const {
|
|
UNIMPLEMENTED();
|
|
return kTagged;
|
|
}
|
|
|
|
|
|
LocationSummary* LoadIndexedInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void LoadIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
Representation StoreIndexedInstr::RequiredInputRepresentation(
|
|
intptr_t idx) const {
|
|
UNIMPLEMENTED();
|
|
return kTagged;
|
|
}
|
|
|
|
|
|
LocationSummary* StoreIndexedInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 3;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RequiresRegister());
|
|
// The smi index is either untagged (element size == 1), or it is left smi
|
|
// tagged (for all element sizes > 1).
|
|
// TODO(regis): Revisit and see if the index can be immediate.
|
|
locs->set_in(1, Location::WritableRegister());
|
|
switch (class_id()) {
|
|
case kArrayCid:
|
|
locs->set_in(2, ShouldEmitStoreBarrier()
|
|
? Location::WritableRegister()
|
|
: Location::RegisterOrConstant(value()));
|
|
break;
|
|
case kExternalTypedDataUint8ArrayCid:
|
|
case kExternalTypedDataUint8ClampedArrayCid:
|
|
case kTypedDataInt8ArrayCid:
|
|
case kTypedDataUint8ArrayCid:
|
|
case kTypedDataUint8ClampedArrayCid:
|
|
case kTypedDataInt16ArrayCid:
|
|
case kTypedDataUint16ArrayCid:
|
|
case kTypedDataInt32ArrayCid:
|
|
case kTypedDataUint32ArrayCid:
|
|
case kTypedDataFloat32ArrayCid:
|
|
case kTypedDataFloat64ArrayCid:
|
|
case kTypedDataFloat32x4ArrayCid:
|
|
UNIMPLEMENTED();
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
return NULL;
|
|
}
|
|
return locs;
|
|
}
|
|
|
|
|
|
void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("StoreIndexedInstr");
|
|
Register array = locs()->in(0).reg();
|
|
Location index = locs()->in(1);
|
|
|
|
Address element_address(kNoRegister, 0);
|
|
if (IsExternal()) {
|
|
UNIMPLEMENTED();
|
|
} else {
|
|
ASSERT(this->array()->definition()->representation() == kTagged);
|
|
ASSERT(index.IsRegister()); // TODO(regis): Revisit.
|
|
// Note that index is expected smi-tagged, (i.e, times 2) for all arrays
|
|
// with index scale factor > 1. E.g., for Uint8Array and OneByteString the
|
|
// index is expected to be untagged before accessing.
|
|
ASSERT(kSmiTagShift == 1);
|
|
switch (index_scale()) {
|
|
case 1: {
|
|
__ SmiUntag(index.reg());
|
|
break;
|
|
}
|
|
case 2: {
|
|
break;
|
|
}
|
|
case 4: {
|
|
__ sll(index.reg(), index.reg(), 1);
|
|
break;
|
|
}
|
|
case 8: {
|
|
__ sll(index.reg(), index.reg(), 2);
|
|
break;
|
|
}
|
|
case 16: {
|
|
__ sll(index.reg(), index.reg(), 3);
|
|
break;
|
|
}
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
__ AddImmediate(index.reg(),
|
|
FlowGraphCompiler::DataOffsetFor(class_id()) - kHeapObjectTag);
|
|
__ addu(TMP1, array, index.reg());
|
|
element_address = Address(TMP1);
|
|
}
|
|
|
|
switch (class_id()) {
|
|
case kArrayCid:
|
|
if (ShouldEmitStoreBarrier()) {
|
|
Register value = locs()->in(2).reg();
|
|
__ StoreIntoObject(array, element_address, value);
|
|
} else if (locs()->in(2).IsConstant()) {
|
|
const Object& constant = locs()->in(2).constant();
|
|
__ StoreIntoObjectNoBarrier(array, element_address, constant);
|
|
} else {
|
|
Register value = locs()->in(2).reg();
|
|
__ StoreIntoObjectNoBarrier(array, element_address, value);
|
|
}
|
|
break;
|
|
case kTypedDataInt8ArrayCid:
|
|
case kTypedDataUint8ArrayCid:
|
|
case kExternalTypedDataUint8ArrayCid:
|
|
case kTypedDataUint8ClampedArrayCid:
|
|
case kExternalTypedDataUint8ClampedArrayCid:
|
|
case kTypedDataInt16ArrayCid:
|
|
case kTypedDataUint16ArrayCid:
|
|
case kTypedDataInt32ArrayCid:
|
|
case kTypedDataUint32ArrayCid:
|
|
case kTypedDataFloat32ArrayCid:
|
|
case kTypedDataFloat64ArrayCid:
|
|
case kTypedDataFloat32x4ArrayCid:
|
|
UNIMPLEMENTED();
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
|
|
LocationSummary* GuardFieldInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs, 0, LocationSummary::kNoCall);
|
|
summary->set_in(0, Location::RequiresRegister());
|
|
if ((value()->Type()->ToCid() == kDynamicCid) &&
|
|
(field().guarded_cid() != kSmiCid)) {
|
|
summary->AddTemp(Location::RequiresRegister());
|
|
}
|
|
if (field().guarded_cid() == kIllegalCid) {
|
|
summary->AddTemp(Location::RequiresRegister());
|
|
}
|
|
return summary;
|
|
}
|
|
|
|
|
|
void GuardFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("GuardFieldInstr");
|
|
const intptr_t field_cid = field().guarded_cid();
|
|
const intptr_t nullability = field().is_nullable() ? kNullCid : kIllegalCid;
|
|
|
|
if (field_cid == kDynamicCid) {
|
|
ASSERT(!compiler->is_optimizing());
|
|
return; // Nothing to emit.
|
|
}
|
|
|
|
const intptr_t value_cid = value()->Type()->ToCid();
|
|
|
|
Register value_reg = locs()->in(0).reg();
|
|
|
|
Register value_cid_reg = ((value_cid == kDynamicCid) &&
|
|
(field_cid != kSmiCid)) ? locs()->temp(0).reg() : kNoRegister;
|
|
|
|
Register field_reg = (field_cid == kIllegalCid) ?
|
|
locs()->temp(locs()->temp_count() - 1).reg() : kNoRegister;
|
|
|
|
Label ok, fail_label;
|
|
|
|
Label* deopt = compiler->is_optimizing() ?
|
|
compiler->AddDeoptStub(deopt_id(), kDeoptGuardField) : NULL;
|
|
|
|
Label* fail = (deopt != NULL) ? deopt : &fail_label;
|
|
|
|
const bool ok_is_fall_through = (deopt != NULL);
|
|
|
|
if (!compiler->is_optimizing() || (field_cid == kIllegalCid)) {
|
|
if (!compiler->is_optimizing()) {
|
|
// Currently we can't have different location summaries for optimized
|
|
// and non-optimized code. So instead we manually pick up a register
|
|
// that is known to be free because we know how non-optimizing compiler
|
|
// allocates registers.
|
|
field_reg = A0;
|
|
ASSERT((field_reg != value_reg) && (field_reg != value_cid_reg));
|
|
}
|
|
|
|
__ LoadObject(field_reg, Field::ZoneHandle(field().raw()));
|
|
|
|
FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset());
|
|
FieldAddress field_nullability_operand(
|
|
field_reg, Field::is_nullable_offset());
|
|
|
|
if (value_cid == kDynamicCid) {
|
|
if (value_cid_reg == kNoRegister) {
|
|
ASSERT(!compiler->is_optimizing());
|
|
value_cid_reg = A1;
|
|
ASSERT((value_cid_reg != value_reg) && (field_reg != value_cid_reg));
|
|
}
|
|
|
|
LoadValueCid(compiler, value_cid_reg, value_reg);
|
|
|
|
__ lw(TMP1, field_cid_operand);
|
|
__ beq(value_cid_reg, TMP1, &ok);
|
|
__ lw(TMP1, field_nullability_operand);
|
|
__ subu(CMPRES, value_cid_reg, TMP1);
|
|
} else if (value_cid == kNullCid) {
|
|
// TODO(regis): TMP1 may conflict. Revisit.
|
|
__ lw(TMP1, field_nullability_operand);
|
|
__ LoadImmediate(TMP2, value_cid);
|
|
__ subu(CMPRES, TMP1, TMP2);
|
|
} else {
|
|
// TODO(regis): TMP1 may conflict. Revisit.
|
|
__ lw(TMP1, field_cid_operand);
|
|
__ LoadImmediate(TMP2, value_cid);
|
|
__ subu(CMPRES, TMP1, TMP2);
|
|
}
|
|
__ beq(CMPRES, ZR, &ok);
|
|
|
|
__ lw(TMP1, field_cid_operand);
|
|
__ BranchNotEqual(TMP1, kIllegalCid, fail);
|
|
|
|
if (value_cid == kDynamicCid) {
|
|
__ sw(value_cid_reg, field_cid_operand);
|
|
__ sw(value_cid_reg, field_nullability_operand);
|
|
} else {
|
|
__ LoadImmediate(TMP1, value_cid);
|
|
__ sw(TMP1, field_cid_operand);
|
|
__ sw(TMP1, field_nullability_operand);
|
|
}
|
|
|
|
if (!ok_is_fall_through) {
|
|
__ b(&ok);
|
|
}
|
|
} else {
|
|
if (value_cid == kDynamicCid) {
|
|
// Field's guarded class id is fixed by value's class id is not known.
|
|
__ andi(CMPRES, value_reg, Immediate(kSmiTagMask));
|
|
|
|
if (field_cid != kSmiCid) {
|
|
__ beq(CMPRES, ZR, fail);
|
|
__ LoadClassId(value_cid_reg, value_reg);
|
|
__ LoadImmediate(TMP1, field_cid);
|
|
__ subu(CMPRES, value_cid_reg, TMP1);
|
|
}
|
|
|
|
if (field().is_nullable() && (field_cid != kNullCid)) {
|
|
__ beq(CMPRES, ZR, &ok);
|
|
__ LoadImmediate(TMP1, reinterpret_cast<intptr_t>(Object::null()));
|
|
__ subu(CMPRES, value_reg, TMP1);
|
|
}
|
|
|
|
if (ok_is_fall_through) {
|
|
__ bne(CMPRES, ZR, fail);
|
|
} else {
|
|
__ beq(CMPRES, ZR, &ok);
|
|
}
|
|
} else {
|
|
// Both value's and field's class id is known.
|
|
if ((value_cid != field_cid) && (value_cid != nullability)) {
|
|
if (ok_is_fall_through) {
|
|
__ b(fail);
|
|
}
|
|
} else {
|
|
// Nothing to emit.
|
|
ASSERT(!compiler->is_optimizing());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (deopt == NULL) {
|
|
ASSERT(!compiler->is_optimizing());
|
|
__ Bind(fail);
|
|
|
|
__ lw(TMP1, FieldAddress(field_reg, Field::guarded_cid_offset()));
|
|
__ BranchEqual(TMP1, kDynamicCid, &ok);
|
|
|
|
__ addiu(SP, SP, Immediate(-2 * kWordSize));
|
|
__ sw(field_reg, Address(SP, 1 * kWordSize));
|
|
__ sw(value_reg, Address(SP, 0 * kWordSize));
|
|
__ CallRuntime(kUpdateFieldCidRuntimeEntry);
|
|
__ Drop(2); // Drop the field and the value.
|
|
}
|
|
|
|
__ Bind(&ok);
|
|
}
|
|
|
|
|
|
LocationSummary* StoreInstanceFieldInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 2;
|
|
const intptr_t num_temps = 0;
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs, num_temps, LocationSummary::kNoCall);
|
|
summary->set_in(0, Location::RequiresRegister());
|
|
summary->set_in(1, ShouldEmitStoreBarrier()
|
|
? Location::WritableRegister()
|
|
: Location::RegisterOrConstant(value()));
|
|
return summary;
|
|
}
|
|
|
|
|
|
void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
Register instance_reg = locs()->in(0).reg();
|
|
if (ShouldEmitStoreBarrier()) {
|
|
Register value_reg = locs()->in(1).reg();
|
|
__ StoreIntoObject(instance_reg,
|
|
FieldAddress(instance_reg, field().Offset()),
|
|
value_reg,
|
|
CanValueBeSmi());
|
|
} else {
|
|
if (locs()->in(1).IsConstant()) {
|
|
__ StoreIntoObjectNoBarrier(
|
|
instance_reg,
|
|
FieldAddress(instance_reg, field().Offset()),
|
|
locs()->in(1).constant());
|
|
} else {
|
|
Register value_reg = locs()->in(1).reg();
|
|
__ StoreIntoObjectNoBarrier(instance_reg,
|
|
FieldAddress(instance_reg, field().Offset()), value_reg);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
LocationSummary* LoadStaticFieldInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(0,
|
|
Location::RequiresRegister(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("LoadStaticFieldInstr");
|
|
Register result = locs()->out().reg();
|
|
__ LoadObject(result, field());
|
|
__ lw(result, Address(result, Field::value_offset() - kHeapObjectTag));
|
|
}
|
|
|
|
|
|
LocationSummary* StoreStaticFieldInstr::MakeLocationSummary() const {
|
|
LocationSummary* locs = new LocationSummary(1, 1, LocationSummary::kNoCall);
|
|
locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
|
|
: Location::RequiresRegister());
|
|
locs->set_temp(0, Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
|
|
|
|
void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("StoreStaticFieldInstr");
|
|
Register value = locs()->in(0).reg();
|
|
Register temp = locs()->temp(0).reg();
|
|
|
|
__ LoadObject(temp, field());
|
|
if (this->value()->NeedsStoreBuffer()) {
|
|
__ StoreIntoObject(temp,
|
|
FieldAddress(temp, Field::value_offset()), value, CanValueBeSmi());
|
|
} else {
|
|
__ StoreIntoObjectNoBarrier(
|
|
temp, FieldAddress(temp, Field::value_offset()), value);
|
|
}
|
|
}
|
|
|
|
|
|
LocationSummary* InstanceOfInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void InstanceOfInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* CreateArrayInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
locs->set_in(0, Location::RegisterLocation(A0));
|
|
locs->set_out(Location::RegisterLocation(V0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("CreateArrayInstr");
|
|
// Allocate the array. A1 = length, A0 = element type.
|
|
ASSERT(locs()->in(0).reg() == A0);
|
|
__ LoadImmediate(A1, Smi::RawValue(num_elements()));
|
|
compiler->GenerateCall(token_pos(),
|
|
&StubCode::AllocateArrayLabel(),
|
|
PcDescriptors::kOther,
|
|
locs());
|
|
ASSERT(locs()->out().reg() == V0);
|
|
}
|
|
|
|
|
|
LocationSummary*
|
|
AllocateObjectWithBoundsCheckInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void AllocateObjectWithBoundsCheckInstr::EmitNativeCode(
|
|
FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* LoadFieldInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(1,
|
|
Location::RequiresRegister(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
Register instance_reg = locs()->in(0).reg();
|
|
Register result_reg = locs()->out().reg();
|
|
|
|
__ lw(result_reg, Address(instance_reg, offset_in_bytes() - kHeapObjectTag));
|
|
}
|
|
|
|
|
|
LocationSummary* InstantiateTypeArgumentsInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
locs->set_in(0, Location::RegisterLocation(T0));
|
|
locs->set_temp(0, Location::RegisterLocation(T1));
|
|
locs->set_out(Location::RegisterLocation(T0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
void InstantiateTypeArgumentsInstr::EmitNativeCode(
|
|
FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("InstantiateTypeArgumentsInstr");
|
|
Register instantiator_reg = locs()->in(0).reg();
|
|
Register temp = locs()->temp(0).reg();
|
|
Register result_reg = locs()->out().reg();
|
|
|
|
// 'instantiator_reg' is the instantiator AbstractTypeArguments object
|
|
// (or null).
|
|
// If the instantiator is null and if the type argument vector
|
|
// instantiated from null becomes a vector of dynamic, then use null as
|
|
// the type arguments.
|
|
Label type_arguments_instantiated;
|
|
const intptr_t len = type_arguments().Length();
|
|
if (type_arguments().IsRawInstantiatedRaw(len)) {
|
|
__ BranchEqual(instantiator_reg, reinterpret_cast<intptr_t>(Object::null()),
|
|
&type_arguments_instantiated);
|
|
}
|
|
// Instantiate non-null type arguments.
|
|
if (type_arguments().IsUninstantiatedIdentity()) {
|
|
// Check if the instantiator type argument vector is a TypeArguments of a
|
|
// matching length and, if so, use it as the instantiated type_arguments.
|
|
// No need to check the instantiator ('instantiator_reg') for null here,
|
|
// because a null instantiator will have the wrong class (Null instead of
|
|
// TypeArguments).
|
|
Label type_arguments_uninstantiated;
|
|
__ LoadClassId(temp, instantiator_reg);
|
|
__ BranchNotEqual(temp, kTypeArgumentsCid, &type_arguments_uninstantiated);
|
|
__ lw(temp, FieldAddress(instantiator_reg, TypeArguments::length_offset()));
|
|
__ BranchEqual(temp, Smi::RawValue(len), &type_arguments_instantiated);
|
|
__ Bind(&type_arguments_uninstantiated);
|
|
}
|
|
// A runtime call to instantiate the type arguments is required.
|
|
__ addiu(SP, SP, Immediate(-3 * kWordSize));
|
|
__ LoadObject(TMP1, Object::ZoneHandle());
|
|
__ LoadObject(TMP2, type_arguments());
|
|
__ sw(TMP1, Address(SP, 2 * kWordSize)); // Make room for the result.
|
|
__ sw(TMP2, Address(SP, 1 * kWordSize));
|
|
// Push instantiator type arguments.
|
|
__ sw(instantiator_reg, Address(SP, 0 * kWordSize));
|
|
|
|
compiler->GenerateCallRuntime(token_pos(),
|
|
deopt_id(),
|
|
kInstantiateTypeArgumentsRuntimeEntry,
|
|
locs());
|
|
// Pop instantiated type arguments.
|
|
__ lw(result_reg, Address(SP, 2 * kWordSize));
|
|
// Drop instantiator and uninstantiated type arguments.
|
|
__ addiu(SP, SP, Immediate(3 * kWordSize));
|
|
__ Bind(&type_arguments_instantiated);
|
|
ASSERT(instantiator_reg == result_reg);
|
|
// 'result_reg': Instantiated type arguments.
|
|
}
|
|
|
|
|
|
LocationSummary*
|
|
ExtractConstructorTypeArgumentsInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RequiresRegister());
|
|
locs->set_out(Location::SameAsFirstInput());
|
|
locs->set_temp(0, Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
|
|
|
|
void ExtractConstructorTypeArgumentsInstr::EmitNativeCode(
|
|
FlowGraphCompiler* compiler) {
|
|
Register instantiator_reg = locs()->in(0).reg();
|
|
Register result_reg = locs()->out().reg();
|
|
ASSERT(instantiator_reg == result_reg);
|
|
Register temp_reg = locs()->temp(0).reg();
|
|
|
|
// instantiator_reg is the instantiator type argument vector, i.e. an
|
|
// AbstractTypeArguments object (or null).
|
|
// If the instantiator is null and if the type argument vector
|
|
// instantiated from null becomes a vector of dynamic, then use null as
|
|
// the type arguments.
|
|
Label type_arguments_instantiated;
|
|
const intptr_t len = type_arguments().Length();
|
|
if (type_arguments().IsRawInstantiatedRaw(len)) {
|
|
__ BranchEqual(instantiator_reg, reinterpret_cast<intptr_t>(Object::null()),
|
|
&type_arguments_instantiated);
|
|
}
|
|
// Instantiate non-null type arguments.
|
|
if (type_arguments().IsUninstantiatedIdentity()) {
|
|
// Check if the instantiator type argument vector is a TypeArguments of a
|
|
// matching length and, if so, use it as the instantiated type_arguments.
|
|
// No need to check instantiator_reg for null here, because a null
|
|
// instantiator will have the wrong class (Null instead of TypeArguments).
|
|
Label type_arguments_uninstantiated;
|
|
__ LoadClassId(temp_reg, instantiator_reg);
|
|
__ BranchNotEqual(temp_reg, kTypeArgumentsCid,
|
|
&type_arguments_uninstantiated);
|
|
__ lw(temp_reg,
|
|
FieldAddress(instantiator_reg, TypeArguments::length_offset()));
|
|
__ BranchEqual(temp_reg, Smi::RawValue(type_arguments().Length()),
|
|
&type_arguments_instantiated);
|
|
__ Bind(&type_arguments_uninstantiated);
|
|
}
|
|
// In the non-factory case, we rely on the allocation stub to
|
|
// instantiate the type arguments.
|
|
__ LoadObject(result_reg, type_arguments());
|
|
// result_reg: uninstantiated type arguments.
|
|
__ Bind(&type_arguments_instantiated);
|
|
// result_reg: uninstantiated or instantiated type arguments.
|
|
}
|
|
|
|
|
|
LocationSummary*
|
|
ExtractConstructorInstantiatorInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RequiresRegister());
|
|
locs->set_out(Location::SameAsFirstInput());
|
|
locs->set_temp(0, Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
|
|
|
|
void ExtractConstructorInstantiatorInstr::EmitNativeCode(
|
|
FlowGraphCompiler* compiler) {
|
|
Register instantiator_reg = locs()->in(0).reg();
|
|
ASSERT(locs()->out().reg() == instantiator_reg);
|
|
Register temp_reg = locs()->temp(0).reg();
|
|
|
|
// instantiator_reg is the instantiator AbstractTypeArguments object
|
|
// (or null). If the instantiator is null and if the type argument vector
|
|
// instantiated from null becomes a vector of dynamic, then use null as
|
|
// the type arguments and do not pass the instantiator.
|
|
Label done;
|
|
const intptr_t len = type_arguments().Length();
|
|
if (type_arguments().IsRawInstantiatedRaw(len)) {
|
|
Label instantiator_not_null;
|
|
__ BranchNotEqual(instantiator_reg,
|
|
reinterpret_cast<intptr_t>(Object::null()), &instantiator_not_null);
|
|
// Null was used in VisitExtractConstructorTypeArguments as the
|
|
// instantiated type arguments, no proper instantiator needed.
|
|
__ LoadImmediate(instantiator_reg,
|
|
Smi::RawValue(StubCode::kNoInstantiator));
|
|
__ b(&done);
|
|
__ Bind(&instantiator_not_null);
|
|
}
|
|
// Instantiate non-null type arguments.
|
|
if (type_arguments().IsUninstantiatedIdentity()) {
|
|
// TODO(regis): The following emitted code is duplicated in
|
|
// VisitExtractConstructorTypeArguments above. The reason is that the code
|
|
// is split between two computations, so that each one produces a
|
|
// single value, rather than producing a pair of values.
|
|
// If this becomes an issue, we should expose these tests at the IL level.
|
|
|
|
// Check if the instantiator type argument vector is a TypeArguments of a
|
|
// matching length and, if so, use it as the instantiated type_arguments.
|
|
// No need to check the instantiator ('instantiator_reg') for null here,
|
|
// because a null instantiator will have the wrong class (Null instead of
|
|
// TypeArguments).
|
|
__ LoadClassId(temp_reg, instantiator_reg);
|
|
__ BranchNotEqual(temp_reg, kTypeArgumentsCid, &done);
|
|
__ lw(temp_reg,
|
|
FieldAddress(instantiator_reg, TypeArguments::length_offset()));
|
|
__ BranchNotEqual(temp_reg, Smi::RawValue(type_arguments().Length()),
|
|
&done);
|
|
// The instantiator was used in VisitExtractConstructorTypeArguments as the
|
|
// instantiated type arguments, no proper instantiator needed.
|
|
__ LoadImmediate(instantiator_reg,
|
|
Smi::RawValue(StubCode::kNoInstantiator));
|
|
}
|
|
__ Bind(&done);
|
|
// instantiator_reg: instantiator or kNoInstantiator.
|
|
}
|
|
|
|
|
|
LocationSummary* AllocateContextInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 0;
|
|
const intptr_t kNumTemps = 1;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
|
|
locs->set_temp(0, Location::RegisterLocation(T1));
|
|
locs->set_out(Location::RegisterLocation(V0));
|
|
return locs;
|
|
}
|
|
|
|
|
|
void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
Register temp = T1;
|
|
ASSERT(locs()->temp(0).reg() == temp);
|
|
ASSERT(locs()->out().reg() == V0);
|
|
|
|
__ TraceSimMsg("AllocateContextInstr");
|
|
__ LoadImmediate(temp, num_context_variables());
|
|
const ExternalLabel label("alloc_context",
|
|
StubCode::AllocateContextEntryPoint());
|
|
compiler->GenerateCall(token_pos(),
|
|
&label,
|
|
PcDescriptors::kOther,
|
|
locs());
|
|
}
|
|
|
|
|
|
LocationSummary* CloneContextInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* CatchEntryInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(0,
|
|
Location::NoLocation(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
// Restore stack and initialize the two exception variables:
|
|
// exception and stack trace variables.
|
|
void CatchEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
// Restore SP from FP as we are coming from a throw and the code for
|
|
// popping arguments has not been run.
|
|
const intptr_t fp_sp_dist =
|
|
(kFirstLocalSlotIndex + 1 - compiler->StackSize()) * kWordSize;
|
|
ASSERT(fp_sp_dist <= 0);
|
|
__ AddImmediate(SP, FP, fp_sp_dist);
|
|
|
|
ASSERT(!exception_var().is_captured());
|
|
ASSERT(!stacktrace_var().is_captured());
|
|
|
|
__ sw(kExceptionObjectReg,
|
|
Address(FP, exception_var().index() * kWordSize));
|
|
__ sw(kStackTraceObjectReg,
|
|
Address(FP, stacktrace_var().index() * kWordSize));
|
|
|
|
Label next;
|
|
__ mov(TMP1, RA); // Save return adress.
|
|
// Restore the pool pointer.
|
|
__ bal(&next); // Branch and link to next instruction to get PC in RA.
|
|
__ delay_slot()->mov(TMP2, RA); // Save PC of the following mov.
|
|
|
|
// Calculate offset of pool pointer from the PC.
|
|
const intptr_t object_pool_pc_dist =
|
|
Instructions::HeaderSize() - Instructions::object_pool_offset() +
|
|
compiler->assembler()->CodeSize();
|
|
|
|
__ Bind(&next);
|
|
__ mov(RA, TMP1); // Restore return address.
|
|
__ lw(PP, Address(TMP2, -object_pool_pc_dist));
|
|
}
|
|
|
|
|
|
LocationSummary* CheckStackOverflowInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 0;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs,
|
|
kNumTemps,
|
|
LocationSummary::kCallOnSlowPath);
|
|
return summary;
|
|
}
|
|
|
|
|
|
class CheckStackOverflowSlowPath : public SlowPathCode {
|
|
public:
|
|
explicit CheckStackOverflowSlowPath(CheckStackOverflowInstr* instruction)
|
|
: instruction_(instruction) { }
|
|
|
|
virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("CheckStackOverflowSlowPath");
|
|
__ Comment("CheckStackOverflowSlowPath");
|
|
__ Bind(entry_label());
|
|
compiler->SaveLiveRegisters(instruction_->locs());
|
|
// pending_deoptimization_env_ is needed to generate a runtime call that
|
|
// may throw an exception.
|
|
ASSERT(compiler->pending_deoptimization_env_ == NULL);
|
|
compiler->pending_deoptimization_env_ = instruction_->env();
|
|
compiler->GenerateCallRuntime(instruction_->token_pos(),
|
|
instruction_->deopt_id(),
|
|
kStackOverflowRuntimeEntry,
|
|
instruction_->locs());
|
|
compiler->pending_deoptimization_env_ = NULL;
|
|
compiler->RestoreLiveRegisters(instruction_->locs());
|
|
__ b(exit_label());
|
|
}
|
|
|
|
private:
|
|
CheckStackOverflowInstr* instruction_;
|
|
};
|
|
|
|
|
|
void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("CheckStackOverflowInstr");
|
|
CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
|
|
compiler->AddSlowPathCode(slow_path);
|
|
|
|
__ LoadImmediate(TMP1, Isolate::Current()->stack_limit_address());
|
|
|
|
__ lw(TMP1, Address(TMP1));
|
|
__ BranchLessEqual(SP, TMP1, slow_path->entry_label());
|
|
|
|
__ Bind(slow_path->exit_label());
|
|
}
|
|
|
|
|
|
LocationSummary* BinarySmiOpInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 2;
|
|
if (op_kind() == Token::kTRUNCDIV) {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
} else {
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
summary->set_in(0, Location::RequiresRegister());
|
|
summary->set_in(1, Location::RegisterOrSmiConstant(right()));
|
|
// We make use of 3-operand instructions by not requiring result register
|
|
// to be identical to first input register as on Intel.
|
|
summary->set_out(Location::RequiresRegister());
|
|
return summary;
|
|
}
|
|
}
|
|
|
|
|
|
void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("BinarySmiOpInstr");
|
|
if (op_kind() == Token::kSHL) {
|
|
UNIMPLEMENTED();
|
|
return;
|
|
}
|
|
|
|
ASSERT(!is_truncating());
|
|
Register left = locs()->in(0).reg();
|
|
Register result = locs()->out().reg();
|
|
Label* deopt = NULL;
|
|
if (CanDeoptimize()) {
|
|
deopt = compiler->AddDeoptStub(deopt_id(), kDeoptBinarySmiOp);
|
|
}
|
|
|
|
if (locs()->in(1).IsConstant()) {
|
|
const Object& constant = locs()->in(1).constant();
|
|
ASSERT(constant.IsSmi());
|
|
int32_t imm = reinterpret_cast<int32_t>(constant.raw());
|
|
switch (op_kind()) {
|
|
case Token::kSUB: {
|
|
if (deopt == NULL) {
|
|
__ AddImmediate(result, left, -imm);
|
|
} else {
|
|
__ SubImmediateDetectOverflow(result, left, imm, CMPRES);
|
|
__ bltz(CMPRES, deopt);
|
|
}
|
|
break;
|
|
}
|
|
case Token::kADD: {
|
|
if (deopt == NULL) {
|
|
__ AddImmediate(result, left, imm);
|
|
} else {
|
|
__ AddImmediateDetectOverflow(result, left, imm, CMPRES);
|
|
__ bltz(CMPRES, deopt);
|
|
}
|
|
break;
|
|
}
|
|
case Token::kMUL: {
|
|
// Keep left value tagged and untag right value.
|
|
const intptr_t value = Smi::Cast(constant).Value();
|
|
if (value == 2) {
|
|
__ sll(result, left, 1);
|
|
} else {
|
|
__ LoadImmediate(TMP1, value);
|
|
__ mult(left, TMP1);
|
|
__ mflo(result);
|
|
}
|
|
if (deopt != NULL) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
break;
|
|
}
|
|
case Token::kTRUNCDIV: {
|
|
UNIMPLEMENTED();
|
|
break;
|
|
}
|
|
case Token::kBIT_AND: {
|
|
// No overflow check.
|
|
if (Utils::IsUint(kImmBits, imm)) {
|
|
__ andi(result, left, Immediate(imm));
|
|
} else {
|
|
__ LoadImmediate(TMP1, imm);
|
|
__ and_(result, left, TMP1);
|
|
}
|
|
break;
|
|
}
|
|
case Token::kBIT_OR: {
|
|
// No overflow check.
|
|
if (Utils::IsUint(kImmBits, imm)) {
|
|
__ ori(result, left, Immediate(imm));
|
|
} else {
|
|
__ LoadImmediate(TMP1, imm);
|
|
__ or_(result, left, TMP1);
|
|
}
|
|
break;
|
|
}
|
|
case Token::kBIT_XOR: {
|
|
// No overflow check.
|
|
if (Utils::IsUint(kImmBits, imm)) {
|
|
__ xori(result, left, Immediate(imm));
|
|
} else {
|
|
__ LoadImmediate(TMP1, imm);
|
|
__ xor_(result, left, TMP1);
|
|
}
|
|
break;
|
|
}
|
|
case Token::kSHR: {
|
|
UNIMPLEMENTED();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
Register right = locs()->in(1).reg();
|
|
switch (op_kind()) {
|
|
case Token::kADD: {
|
|
if (deopt == NULL) {
|
|
__ addu(result, left, right);
|
|
} else {
|
|
__ AdduDetectOverflow(result, left, right, CMPRES);
|
|
__ bltz(CMPRES, deopt);
|
|
}
|
|
break;
|
|
}
|
|
case Token::kSUB: {
|
|
if (deopt == NULL) {
|
|
__ subu(result, left, right);
|
|
} else {
|
|
__ SubuDetectOverflow(result, left, right, CMPRES);
|
|
__ bltz(CMPRES, deopt);
|
|
}
|
|
break;
|
|
}
|
|
case Token::kMUL: {
|
|
__ SmiUntag(left);
|
|
__ mult(left, right);
|
|
__ mflo(result);
|
|
if (deopt != NULL) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
break;
|
|
}
|
|
case Token::kBIT_AND: {
|
|
// No overflow check.
|
|
__ and_(result, left, right);
|
|
break;
|
|
}
|
|
case Token::kBIT_OR: {
|
|
// No overflow check.
|
|
__ or_(result, left, right);
|
|
break;
|
|
}
|
|
case Token::kBIT_XOR: {
|
|
// No overflow check.
|
|
__ xor_(result, left, right);
|
|
break;
|
|
}
|
|
case Token::kTRUNCDIV: {
|
|
UNIMPLEMENTED();
|
|
break;
|
|
}
|
|
case Token::kSHR: {
|
|
UNIMPLEMENTED();
|
|
break;
|
|
}
|
|
case Token::kDIV: {
|
|
// Dispatches to 'Double./'.
|
|
// TODO(srdjan): Implement as conversion to double and double division.
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
case Token::kMOD: {
|
|
// TODO(srdjan): Implement.
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
case Token::kOR:
|
|
case Token::kAND: {
|
|
// Flow graph builder has dissected this operation to guarantee correct
|
|
// behavior (short-circuit evaluation).
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
LocationSummary* CheckEitherNonSmiInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void CheckEitherNonSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* BoxDoubleInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void BoxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* UnboxDoubleInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void UnboxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* BoxFloat32x4Instr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void BoxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* UnboxFloat32x4Instr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void UnboxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* BinaryDoubleOpInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void BinaryDoubleOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* BinaryFloat32x4OpInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void BinaryFloat32x4OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* Float32x4ShuffleInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void Float32x4ShuffleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* MathSqrtInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void MathSqrtInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* UnarySmiOpInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void UnarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* SmiToDoubleInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void SmiToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* DoubleToIntegerInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void DoubleToIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* DoubleToSmiInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void DoubleToSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* DoubleToDoubleInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void DoubleToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* InvokeMathCFunctionInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void InvokeMathCFunctionInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary() const {
|
|
return MakeCallSummary();
|
|
}
|
|
|
|
|
|
void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("PolymorphicInstanceCallInstr");
|
|
Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
|
|
kDeoptPolymorphicInstanceCallTestFail);
|
|
if (ic_data().NumberOfChecks() == 0) {
|
|
__ b(deopt);
|
|
return;
|
|
}
|
|
ASSERT(ic_data().num_args_tested() == 1);
|
|
if (!with_checks()) {
|
|
ASSERT(ic_data().HasOneTarget());
|
|
const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
|
|
compiler->GenerateStaticCall(instance_call()->deopt_id(),
|
|
instance_call()->token_pos(),
|
|
target,
|
|
instance_call()->ArgumentCount(),
|
|
instance_call()->argument_names(),
|
|
locs());
|
|
return;
|
|
}
|
|
|
|
// Load receiver into T0.
|
|
__ lw(T0, Address(SP, (instance_call()->ArgumentCount() - 1) * kWordSize));
|
|
|
|
LoadValueCid(compiler, T2, T0,
|
|
(ic_data().GetReceiverClassIdAt(0) == kSmiCid) ? NULL : deopt);
|
|
|
|
compiler->EmitTestAndCall(ic_data(),
|
|
T2, // Class id register.
|
|
instance_call()->ArgumentCount(),
|
|
instance_call()->argument_names(),
|
|
deopt,
|
|
instance_call()->deopt_id(),
|
|
instance_call()->token_pos(),
|
|
locs());
|
|
}
|
|
|
|
|
|
LocationSummary* BranchInstr::MakeLocationSummary() const {
|
|
UNREACHABLE();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("BranchInstr");
|
|
comparison()->EmitBranchCode(compiler, this);
|
|
}
|
|
|
|
|
|
LocationSummary* CheckClassInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void CheckClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* CheckSmiInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 1;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* summary =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
summary->set_in(0, Location::RequiresRegister());
|
|
return summary;
|
|
}
|
|
|
|
|
|
void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("CheckSmiInstr");
|
|
Register value = locs()->in(0).reg();
|
|
Label* deopt = compiler->AddDeoptStub(deopt_id(),
|
|
kDeoptCheckSmi);
|
|
__ andi(TMP1, value, Immediate(kSmiTagMask));
|
|
__ bne(TMP1, ZR, deopt);
|
|
}
|
|
|
|
|
|
LocationSummary* CheckArrayBoundInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void CheckArrayBoundInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* UnboxIntegerInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void UnboxIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* BoxIntegerInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void BoxIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* BinaryMintOpInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void BinaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* ShiftMintOpInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* UnaryMintOpInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void UnaryMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* ThrowInstr::MakeLocationSummary() const {
|
|
return new LocationSummary(0, 0, LocationSummary::kCall);
|
|
}
|
|
|
|
|
|
|
|
void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
compiler->GenerateCallRuntime(token_pos(),
|
|
deopt_id(),
|
|
kThrowRuntimeEntry,
|
|
locs());
|
|
__ break_(0);
|
|
}
|
|
|
|
|
|
LocationSummary* ReThrowInstr::MakeLocationSummary() const {
|
|
return new LocationSummary(0, 0, LocationSummary::kCall);
|
|
}
|
|
|
|
|
|
void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
compiler->GenerateCallRuntime(token_pos(),
|
|
deopt_id(),
|
|
kReThrowRuntimeEntry,
|
|
locs());
|
|
__ break_(0);
|
|
}
|
|
|
|
|
|
LocationSummary* GotoInstr::MakeLocationSummary() const {
|
|
return new LocationSummary(0, 0, LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("GotoInstr");
|
|
// Add deoptimization descriptor for deoptimizing instructions
|
|
// that may be inserted before this instruction.
|
|
if (!compiler->is_optimizing()) {
|
|
compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
|
|
GetDeoptId(),
|
|
0); // No token position.
|
|
}
|
|
|
|
if (HasParallelMove()) {
|
|
compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
|
|
}
|
|
|
|
// We can fall through if the successor is the next block in the list.
|
|
// Otherwise, we need a jump.
|
|
if (!compiler->CanFallThroughTo(successor())) {
|
|
__ b(compiler->GetJumpLabel(successor()));
|
|
}
|
|
}
|
|
|
|
|
|
static Condition NegateCondition(Condition condition) {
|
|
switch (condition) {
|
|
case EQ: return NE;
|
|
case NE: return EQ;
|
|
case LT: return GE;
|
|
case LE: return GT;
|
|
case GT: return LE;
|
|
case GE: return LT;
|
|
default:
|
|
OS::Print("Error: Condition not recognized: %d\n", condition);
|
|
UNIMPLEMENTED();
|
|
return EQ;
|
|
}
|
|
}
|
|
|
|
|
|
void ControlInstruction::EmitBranchOnValue(FlowGraphCompiler* compiler,
|
|
bool value) {
|
|
__ TraceSimMsg("ControlInstruction::EmitBranchOnValue");
|
|
if (value && !compiler->CanFallThroughTo(true_successor())) {
|
|
__ b(compiler->GetJumpLabel(true_successor()));
|
|
} else if (!value && !compiler->CanFallThroughTo(false_successor())) {
|
|
__ b(compiler->GetJumpLabel(false_successor()));
|
|
}
|
|
}
|
|
|
|
|
|
// The comparison result is in CMPRES.
|
|
void ControlInstruction::EmitBranchOnCondition(FlowGraphCompiler* compiler,
|
|
Condition true_condition) {
|
|
__ TraceSimMsg("ControlInstruction::EmitBranchOnCondition");
|
|
if (compiler->CanFallThroughTo(false_successor())) {
|
|
// If the next block is the false successor we will fall through to it.
|
|
Label* label = compiler->GetJumpLabel(true_successor());
|
|
switch (true_condition) {
|
|
case EQ: __ beq(CMPRES, ZR, label); break;
|
|
case NE: __ bne(CMPRES, ZR, label); break;
|
|
case GT: __ bgtz(CMPRES, label); break;
|
|
case GE: __ bgez(CMPRES, label); break;
|
|
case LT: __ bltz(CMPRES, label); break;
|
|
case LE: __ blez(CMPRES, label); break;
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
} else {
|
|
// If the next block is the true successor we negate comparison and fall
|
|
// through to it.
|
|
Condition false_condition = NegateCondition(true_condition);
|
|
Label* label = compiler->GetJumpLabel(false_successor());
|
|
switch (false_condition) {
|
|
case EQ: __ beq(CMPRES, ZR, label); break;
|
|
case NE: __ bne(CMPRES, ZR, label); break;
|
|
case GT: __ bgtz(CMPRES, label); break;
|
|
case GE: __ bgez(CMPRES, label); break;
|
|
case LT: __ bltz(CMPRES, label); break;
|
|
case LE: __ blez(CMPRES, label); break;
|
|
default:
|
|
UNREACHABLE();
|
|
break;
|
|
}
|
|
// Fall through or jump to the true successor.
|
|
if (!compiler->CanFallThroughTo(true_successor())) {
|
|
__ b(compiler->GetJumpLabel(true_successor()));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
LocationSummary* CurrentContextInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(0,
|
|
Location::RequiresRegister(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ mov(locs()->out().reg(), CTX);
|
|
}
|
|
|
|
|
|
LocationSummary* StrictCompareInstr::MakeLocationSummary() const {
|
|
const intptr_t kNumInputs = 2;
|
|
const intptr_t kNumTemps = 0;
|
|
LocationSummary* locs =
|
|
new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
|
|
locs->set_in(0, Location::RegisterOrConstant(left()));
|
|
locs->set_in(1, Location::RegisterOrConstant(right()));
|
|
locs->set_out(Location::RequiresRegister());
|
|
return locs;
|
|
}
|
|
|
|
|
|
// Special code for numbers (compare values instead of references.)
|
|
void StrictCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("StrictCompareInstr");
|
|
ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
|
|
Location left = locs()->in(0);
|
|
Location right = locs()->in(1);
|
|
if (left.IsConstant() && right.IsConstant()) {
|
|
// TODO(vegorov): should be eliminated earlier by constant propagation.
|
|
const bool result = (kind() == Token::kEQ_STRICT) ?
|
|
left.constant().raw() == right.constant().raw() :
|
|
left.constant().raw() != right.constant().raw();
|
|
__ LoadObject(locs()->out().reg(), result ? Bool::True() : Bool::False());
|
|
return;
|
|
}
|
|
if (left.IsConstant()) {
|
|
compiler->EmitEqualityRegConstCompare(right.reg(),
|
|
left.constant(),
|
|
needs_number_check());
|
|
} else if (right.IsConstant()) {
|
|
compiler->EmitEqualityRegConstCompare(left.reg(),
|
|
right.constant(),
|
|
needs_number_check());
|
|
} else {
|
|
compiler->EmitEqualityRegRegCompare(left.reg(),
|
|
right.reg(),
|
|
needs_number_check());
|
|
}
|
|
|
|
Register result = locs()->out().reg();
|
|
Label load_true, done;
|
|
if (kind() == Token::kEQ_STRICT) {
|
|
__ beq(CMPRES, ZR, &load_true);
|
|
} else {
|
|
ASSERT(kind() == Token::kNE_STRICT);
|
|
__ bne(CMPRES, ZR, &load_true);
|
|
}
|
|
__ LoadObject(result, Bool::False());
|
|
__ b(&done);
|
|
__ Bind(&load_true);
|
|
__ LoadObject(result, Bool::True());
|
|
__ Bind(&done);
|
|
}
|
|
|
|
|
|
void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
|
|
BranchInstr* branch) {
|
|
__ TraceSimMsg("StrictCompareInstr::EmitBranchCode");
|
|
ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
|
|
Location left = locs()->in(0);
|
|
Location right = locs()->in(1);
|
|
if (left.IsConstant() && right.IsConstant()) {
|
|
// TODO(vegorov): should be eliminated earlier by constant propagation.
|
|
const bool result = (kind() == Token::kEQ_STRICT) ?
|
|
left.constant().raw() == right.constant().raw() :
|
|
left.constant().raw() != right.constant().raw();
|
|
branch->EmitBranchOnValue(compiler, result);
|
|
return;
|
|
}
|
|
if (left.IsConstant()) {
|
|
compiler->EmitEqualityRegConstCompare(right.reg(),
|
|
left.constant(),
|
|
needs_number_check());
|
|
} else if (right.IsConstant()) {
|
|
compiler->EmitEqualityRegConstCompare(left.reg(),
|
|
right.constant(),
|
|
needs_number_check());
|
|
} else {
|
|
compiler->EmitEqualityRegRegCompare(left.reg(),
|
|
right.reg(),
|
|
needs_number_check());
|
|
}
|
|
|
|
Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQ : NE;
|
|
branch->EmitBranchOnCondition(compiler, true_condition);
|
|
}
|
|
|
|
|
|
LocationSummary* BooleanNegateInstr::MakeLocationSummary() const {
|
|
return LocationSummary::Make(1,
|
|
Location::RequiresRegister(),
|
|
LocationSummary::kNoCall);
|
|
}
|
|
|
|
|
|
void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
Register value = locs()->in(0).reg();
|
|
Register result = locs()->out().reg();
|
|
|
|
__ LoadObject(result, Bool::True());
|
|
__ LoadObject(TMP1, Bool::False());
|
|
__ subu(CMPRES, value, result);
|
|
__ movz(result, TMP1, CMPRES); // If value is True, move False into result.
|
|
}
|
|
|
|
|
|
LocationSummary* ChainContextInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void ChainContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* StoreVMFieldInstr::MakeLocationSummary() const {
|
|
UNIMPLEMENTED();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void StoreVMFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
UNIMPLEMENTED();
|
|
}
|
|
|
|
|
|
LocationSummary* AllocateObjectInstr::MakeLocationSummary() const {
|
|
return MakeCallSummary();
|
|
}
|
|
|
|
|
|
void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
__ TraceSimMsg("AllocateObjectInstr");
|
|
const Class& cls = Class::ZoneHandle(constructor().Owner());
|
|
const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
|
|
const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
|
|
compiler->GenerateCall(token_pos(),
|
|
&label,
|
|
PcDescriptors::kOther,
|
|
locs());
|
|
__ Drop(ArgumentCount()); // Discard arguments.
|
|
}
|
|
|
|
|
|
LocationSummary* CreateClosureInstr::MakeLocationSummary() const {
|
|
return MakeCallSummary();
|
|
}
|
|
|
|
|
|
void CreateClosureInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
|
|
const Function& closure_function = function();
|
|
ASSERT(!closure_function.IsImplicitStaticClosureFunction());
|
|
const Code& stub = Code::Handle(
|
|
StubCode::GetAllocationStubForClosure(closure_function));
|
|
const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
|
|
compiler->GenerateCall(token_pos(),
|
|
&label,
|
|
PcDescriptors::kOther,
|
|
locs());
|
|
__ Drop(2); // Discard type arguments and receiver.
|
|
}
|
|
|
|
} // namespace dart
|
|
|
|
#endif // defined TARGET_ARCH_MIPS
|
|
|