Alexander Markov
45f42d0be8
This change removes distinct Slots for the same field: PointerBase_data_field -> PointerBase_data Pointer_data_field -> PointerBase_data TypedDataBase_data_field -> PointerBase_data Also, the following slot is renamed to match field name: TypedDataView_data -> TypedDataView_typed_data The following offsets are renamed to match field names / declarations in Untagged* classes: PointerBase::data_field_offset -> PointerBase::data_offset TypedData::data_offset -> TypedData::payload_offset TypedDataView::data_offset -> TypedDataView::typed_data_offset TEST=ci Fixes https://github.com/dart-lang/sdk/issues/48273 Change-Id: I602545fc43018494bcb24d8692292fdbc6a8f3e0 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/231160 Reviewed-by: Martin Kustermann <kustermann@google.com> Reviewed-by: Daco Harkes <dacoharkes@google.com> Commit-Queue: Alexander Markov <alexmarkov@google.com>
1773 lines
67 KiB
C++
1773 lines
67 KiB
C++
// Copyright (c) 2017, 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/compiler/call_specializer.h"
|
|
|
|
#include "vm/compiler/backend/flow_graph_compiler.h"
|
|
#include "vm/compiler/backend/inliner.h"
|
|
#include "vm/compiler/cha.h"
|
|
#include "vm/compiler/compiler_state.h"
|
|
#include "vm/cpu.h"
|
|
|
|
namespace dart {
|
|
|
|
// Quick access to the current isolate and zone.
|
|
#define IG (isolate_group())
|
|
#define Z (zone())
|
|
|
|
static void RefineUseTypes(Definition* instr) {
|
|
CompileType* new_type = instr->Type();
|
|
for (Value::Iterator it(instr->input_use_list()); !it.Done(); it.Advance()) {
|
|
it.Current()->RefineReachingType(new_type);
|
|
}
|
|
}
|
|
|
|
static bool ShouldInlineSimd() {
|
|
return FlowGraphCompiler::SupportsUnboxedSimd128();
|
|
}
|
|
|
|
static bool CanUnboxDouble() {
|
|
return FlowGraphCompiler::SupportsUnboxedDoubles();
|
|
}
|
|
|
|
static bool CanConvertInt64ToDouble() {
|
|
return FlowGraphCompiler::CanConvertInt64ToDouble();
|
|
}
|
|
|
|
static bool IsNumberCid(intptr_t cid) {
|
|
return (cid == kSmiCid) || (cid == kDoubleCid);
|
|
}
|
|
|
|
static bool ShouldSpecializeForDouble(const BinaryFeedback& binary_feedback) {
|
|
// Don't specialize for double if we can't unbox them.
|
|
if (!CanUnboxDouble()) {
|
|
return false;
|
|
}
|
|
|
|
// Unboxed double operation can't handle case of two smis.
|
|
if (binary_feedback.IncludesOperands(kSmiCid)) {
|
|
return false;
|
|
}
|
|
|
|
// Check that the call site has seen only smis and doubles.
|
|
return binary_feedback.OperandsAreSmiOrDouble();
|
|
}
|
|
|
|
// Optimize instance calls using ICData.
|
|
void CallSpecializer::ApplyICData() {
|
|
VisitBlocks();
|
|
}
|
|
|
|
// Optimize instance calls using cid. This is called after optimizer
|
|
// converted instance calls to instructions. Any remaining
|
|
// instance calls are either megamorphic calls, cannot be optimized or
|
|
// have no runtime type feedback collected.
|
|
// Attempts to convert an instance call (IC call) using propagated class-ids,
|
|
// e.g., receiver class id, guarded-cid, or by guessing cid-s.
|
|
void CallSpecializer::ApplyClassIds() {
|
|
ASSERT(current_iterator_ == NULL);
|
|
for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
|
|
!block_it.Done(); block_it.Advance()) {
|
|
thread()->CheckForSafepoint();
|
|
ForwardInstructionIterator it(block_it.Current());
|
|
current_iterator_ = ⁢
|
|
for (; !it.Done(); it.Advance()) {
|
|
Instruction* instr = it.Current();
|
|
if (instr->IsInstanceCall()) {
|
|
InstanceCallInstr* call = instr->AsInstanceCall();
|
|
if (call->HasICData()) {
|
|
if (TryCreateICData(call)) {
|
|
VisitInstanceCall(call);
|
|
}
|
|
}
|
|
} else if (auto static_call = instr->AsStaticCall()) {
|
|
// If TFA devirtualized instance calls to static calls we also want to
|
|
// process them here.
|
|
VisitStaticCall(static_call);
|
|
} else if (instr->IsPolymorphicInstanceCall()) {
|
|
SpecializePolymorphicInstanceCall(instr->AsPolymorphicInstanceCall());
|
|
}
|
|
}
|
|
current_iterator_ = NULL;
|
|
}
|
|
}
|
|
|
|
bool CallSpecializer::TryCreateICData(InstanceCallInstr* call) {
|
|
ASSERT(call->HasICData());
|
|
|
|
if (call->Targets().length() > 0) {
|
|
// This occurs when an instance call has too many checks, will be converted
|
|
// to megamorphic call.
|
|
return false;
|
|
}
|
|
|
|
const intptr_t receiver_index = call->FirstArgIndex();
|
|
GrowableArray<intptr_t> class_ids(call->ic_data()->NumArgsTested());
|
|
ASSERT(call->ic_data()->NumArgsTested() <=
|
|
call->ArgumentCountWithoutTypeArgs());
|
|
for (intptr_t i = 0; i < call->ic_data()->NumArgsTested(); i++) {
|
|
class_ids.Add(call->ArgumentValueAt(receiver_index + i)->Type()->ToCid());
|
|
}
|
|
|
|
const Token::Kind op_kind = call->token_kind();
|
|
if (FLAG_guess_icdata_cid && !CompilerState::Current().is_aot()) {
|
|
if (Token::IsRelationalOperator(op_kind) ||
|
|
Token::IsEqualityOperator(op_kind) ||
|
|
Token::IsBinaryOperator(op_kind)) {
|
|
// Guess cid: if one of the inputs is a number assume that the other
|
|
// is a number of same type, unless the interface target tells us this
|
|
// is impossible.
|
|
if (call->CanReceiverBeSmiBasedOnInterfaceTarget(zone())) {
|
|
const intptr_t cid_0 = class_ids[0];
|
|
const intptr_t cid_1 = class_ids[1];
|
|
if ((cid_0 == kDynamicCid) && (IsNumberCid(cid_1))) {
|
|
class_ids[0] = cid_1;
|
|
} else if (IsNumberCid(cid_0) && (cid_1 == kDynamicCid)) {
|
|
class_ids[1] = cid_0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool all_cids_known = true;
|
|
for (intptr_t i = 0; i < class_ids.length(); i++) {
|
|
if (class_ids[i] == kDynamicCid) {
|
|
// Not all cid-s known.
|
|
all_cids_known = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (all_cids_known) {
|
|
const intptr_t receiver_cid = class_ids[0];
|
|
if (receiver_cid == kSentinelCid) {
|
|
// Unreachable call.
|
|
return false;
|
|
}
|
|
const Class& receiver_class =
|
|
Class::Handle(Z, IG->class_table()->At(receiver_cid));
|
|
if (!receiver_class.is_finalized()) {
|
|
// Do not eagerly finalize classes. ResolveDynamicForReceiverClass can
|
|
// cause class finalization, since callee's receiver class may not be
|
|
// finalized yet.
|
|
return false;
|
|
}
|
|
const Function& function = Function::Handle(
|
|
Z, call->ResolveForReceiverClass(receiver_class, /*allow_add=*/false));
|
|
if (function.IsNull()) {
|
|
return false;
|
|
}
|
|
ASSERT(!function.IsInvokeFieldDispatcher());
|
|
|
|
// Update the CallTargets attached to the instruction with our speculative
|
|
// target. The next round of CallSpecializer::VisitInstanceCall will make
|
|
// use of this.
|
|
call->SetTargets(CallTargets::CreateMonomorphic(Z, class_ids[0], function));
|
|
if (class_ids.length() == 2) {
|
|
call->SetBinaryFeedback(
|
|
BinaryFeedback::CreateMonomorphic(Z, class_ids[0], class_ids[1]));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CallSpecializer::SpecializePolymorphicInstanceCall(
|
|
PolymorphicInstanceCallInstr* call) {
|
|
if (!FLAG_polymorphic_with_deopt) {
|
|
// Specialization adds receiver checks which can lead to deoptimization.
|
|
return;
|
|
}
|
|
|
|
const intptr_t receiver_cid = call->Receiver()->Type()->ToCid();
|
|
if (receiver_cid == kDynamicCid) {
|
|
return; // No information about receiver was infered.
|
|
}
|
|
|
|
const ICData& ic_data = *call->ic_data();
|
|
|
|
const CallTargets* targets =
|
|
FlowGraphCompiler::ResolveCallTargetsForReceiverCid(
|
|
receiver_cid, String::Handle(zone(), ic_data.target_name()),
|
|
Array::Handle(zone(), ic_data.arguments_descriptor()));
|
|
if (targets == NULL) {
|
|
// No specialization.
|
|
return;
|
|
}
|
|
|
|
ASSERT(targets->HasSingleTarget());
|
|
const Function& target = targets->FirstTarget();
|
|
StaticCallInstr* specialized =
|
|
StaticCallInstr::FromCall(Z, call, target, targets->AggregateCallCount());
|
|
call->ReplaceWith(specialized, current_iterator());
|
|
}
|
|
|
|
void CallSpecializer::ReplaceCallWithResult(Definition* call,
|
|
Instruction* replacement,
|
|
Definition* result) {
|
|
ASSERT(!call->HasPushArguments());
|
|
if (result == nullptr) {
|
|
ASSERT(replacement->IsDefinition());
|
|
call->ReplaceWith(replacement->AsDefinition(), current_iterator());
|
|
} else {
|
|
call->ReplaceWithResult(replacement, result, current_iterator());
|
|
}
|
|
}
|
|
|
|
void CallSpecializer::ReplaceCall(Definition* call, Definition* replacement) {
|
|
ReplaceCallWithResult(call, replacement, nullptr);
|
|
}
|
|
|
|
void CallSpecializer::AddCheckSmi(Definition* to_check,
|
|
intptr_t deopt_id,
|
|
Environment* deopt_environment,
|
|
Instruction* insert_before) {
|
|
// TODO(alexmarkov): check reaching type instead of definition type
|
|
if (to_check->Type()->ToCid() != kSmiCid) {
|
|
InsertBefore(insert_before,
|
|
new (Z) CheckSmiInstr(new (Z) Value(to_check), deopt_id,
|
|
insert_before->source()),
|
|
deopt_environment, FlowGraph::kEffect);
|
|
}
|
|
}
|
|
|
|
void CallSpecializer::AddCheckClass(Definition* to_check,
|
|
const Cids& cids,
|
|
intptr_t deopt_id,
|
|
Environment* deopt_environment,
|
|
Instruction* insert_before) {
|
|
// Type propagation has not run yet, we cannot eliminate the check.
|
|
Instruction* check = flow_graph_->CreateCheckClass(to_check, cids, deopt_id,
|
|
insert_before->source());
|
|
InsertBefore(insert_before, check, deopt_environment, FlowGraph::kEffect);
|
|
}
|
|
|
|
void CallSpecializer::AddChecksForArgNr(InstanceCallInstr* call,
|
|
Definition* argument,
|
|
int argument_number) {
|
|
const Cids* cids =
|
|
Cids::CreateForArgument(zone(), call->BinaryFeedback(), argument_number);
|
|
AddCheckClass(argument, *cids, call->deopt_id(), call->env(), call);
|
|
}
|
|
|
|
void CallSpecializer::AddCheckNull(Value* to_check,
|
|
const String& function_name,
|
|
intptr_t deopt_id,
|
|
Environment* deopt_environment,
|
|
Instruction* insert_before) {
|
|
if (to_check->Type()->is_nullable()) {
|
|
CheckNullInstr* check_null =
|
|
new (Z) CheckNullInstr(to_check->CopyWithType(Z), function_name,
|
|
deopt_id, insert_before->source());
|
|
if (FLAG_trace_strong_mode_types) {
|
|
THR_Print("[Strong mode] Inserted %s\n", check_null->ToCString());
|
|
}
|
|
InsertBefore(insert_before, check_null, deopt_environment,
|
|
FlowGraph::kEffect);
|
|
}
|
|
}
|
|
|
|
bool CallSpecializer::TryReplaceWithIndexedOp(InstanceCallInstr* call) {
|
|
if (call->Targets().IsMonomorphic()) {
|
|
return FlowGraphInliner::TryReplaceInstanceCallWithInline(
|
|
flow_graph_, current_iterator(), call, speculative_policy_);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Return true if d is a string of length one (a constant or result from
|
|
// from string-from-char-code instruction.
|
|
static bool IsLengthOneString(Definition* d) {
|
|
if (d->IsConstant()) {
|
|
const Object& obj = d->AsConstant()->value();
|
|
if (obj.IsString()) {
|
|
return String::Cast(obj).Length() == 1;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return d->IsOneByteStringFromCharCode();
|
|
}
|
|
}
|
|
|
|
// Returns true if the string comparison was converted into char-code
|
|
// comparison. Conversion is only possible for strings of length one.
|
|
// E.g., detect str[x] == "x"; and use an integer comparison of char-codes.
|
|
bool CallSpecializer::TryStringLengthOneEquality(InstanceCallInstr* call,
|
|
Token::Kind op_kind) {
|
|
ASSERT(call->BinaryFeedback().OperandsAre(kOneByteStringCid));
|
|
// Check that left and right are length one strings (either string constants
|
|
// or results of string-from-char-code.
|
|
Definition* left = call->ArgumentAt(0);
|
|
Definition* right = call->ArgumentAt(1);
|
|
Value* left_val = NULL;
|
|
Definition* to_remove_left = NULL;
|
|
if (IsLengthOneString(right)) {
|
|
// Swap, since we know that both arguments are strings
|
|
Definition* temp = left;
|
|
left = right;
|
|
right = temp;
|
|
}
|
|
if (IsLengthOneString(left)) {
|
|
// Optimize if left is a string with length one (either constant or
|
|
// result of string-from-char-code.
|
|
if (left->IsConstant()) {
|
|
ConstantInstr* left_const = left->AsConstant();
|
|
const String& str = String::Cast(left_const->value());
|
|
ASSERT(str.Length() == 1);
|
|
ConstantInstr* char_code_left = flow_graph()->GetConstant(
|
|
Smi::ZoneHandle(Z, Smi::New(static_cast<intptr_t>(str.CharAt(0)))));
|
|
left_val = new (Z) Value(char_code_left);
|
|
} else if (left->IsOneByteStringFromCharCode()) {
|
|
// Use input of string-from-charcode as left value.
|
|
OneByteStringFromCharCodeInstr* instr =
|
|
left->AsOneByteStringFromCharCode();
|
|
left_val = new (Z) Value(instr->char_code()->definition());
|
|
to_remove_left = instr;
|
|
} else {
|
|
// IsLengthOneString(left) should have been false.
|
|
UNREACHABLE();
|
|
}
|
|
|
|
Definition* to_remove_right = NULL;
|
|
Value* right_val = NULL;
|
|
if (right->IsOneByteStringFromCharCode()) {
|
|
// Skip string-from-char-code, and use its input as right value.
|
|
OneByteStringFromCharCodeInstr* right_instr =
|
|
right->AsOneByteStringFromCharCode();
|
|
right_val = new (Z) Value(right_instr->char_code()->definition());
|
|
to_remove_right = right_instr;
|
|
} else {
|
|
AddChecksForArgNr(call, right, /* arg_number = */ 1);
|
|
// String-to-char-code instructions returns -1 (illegal charcode) if
|
|
// string is not of length one.
|
|
StringToCharCodeInstr* char_code_right = new (Z)
|
|
StringToCharCodeInstr(new (Z) Value(right), kOneByteStringCid);
|
|
InsertBefore(call, char_code_right, call->env(), FlowGraph::kValue);
|
|
right_val = new (Z) Value(char_code_right);
|
|
}
|
|
|
|
// Comparing char-codes instead of strings.
|
|
EqualityCompareInstr* comp =
|
|
new (Z) EqualityCompareInstr(call->source(), op_kind, left_val,
|
|
right_val, kSmiCid, call->deopt_id());
|
|
ReplaceCall(call, comp);
|
|
|
|
// Remove dead instructions.
|
|
if ((to_remove_left != NULL) &&
|
|
(to_remove_left->input_use_list() == NULL)) {
|
|
to_remove_left->ReplaceUsesWith(flow_graph()->constant_null());
|
|
to_remove_left->RemoveFromGraph();
|
|
}
|
|
if ((to_remove_right != NULL) &&
|
|
(to_remove_right->input_use_list() == NULL)) {
|
|
to_remove_right->ReplaceUsesWith(flow_graph()->constant_null());
|
|
to_remove_right->RemoveFromGraph();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool SmiFitsInDouble() {
|
|
return compiler::target::kSmiBits < 53;
|
|
}
|
|
|
|
bool CallSpecializer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
|
|
Token::Kind op_kind) {
|
|
const BinaryFeedback& binary_feedback = call->BinaryFeedback();
|
|
|
|
ASSERT(call->type_args_len() == 0);
|
|
ASSERT(call->ArgumentCount() == 2);
|
|
Definition* const left = call->ArgumentAt(0);
|
|
Definition* const right = call->ArgumentAt(1);
|
|
|
|
intptr_t cid = kIllegalCid;
|
|
if (binary_feedback.OperandsAre(kOneByteStringCid)) {
|
|
return TryStringLengthOneEquality(call, op_kind);
|
|
} else if (binary_feedback.OperandsAre(kSmiCid)) {
|
|
InsertBefore(call,
|
|
new (Z) CheckSmiInstr(new (Z) Value(left), call->deopt_id(),
|
|
call->source()),
|
|
call->env(), FlowGraph::kEffect);
|
|
InsertBefore(call,
|
|
new (Z) CheckSmiInstr(new (Z) Value(right), call->deopt_id(),
|
|
call->source()),
|
|
call->env(), FlowGraph::kEffect);
|
|
cid = kSmiCid;
|
|
} else if (binary_feedback.OperandsAreSmiOrMint()) {
|
|
cid = kMintCid;
|
|
} else if (binary_feedback.OperandsAreSmiOrDouble() && CanUnboxDouble()) {
|
|
// Use double comparison.
|
|
if (SmiFitsInDouble()) {
|
|
cid = kDoubleCid;
|
|
} else {
|
|
if (binary_feedback.IncludesOperands(kSmiCid)) {
|
|
// We cannot use double comparison on two smis. Need polymorphic
|
|
// call.
|
|
return false;
|
|
} else {
|
|
InsertBefore(
|
|
call,
|
|
new (Z) CheckEitherNonSmiInstr(
|
|
new (Z) Value(left), new (Z) Value(right), call->deopt_id()),
|
|
call->env(), FlowGraph::kEffect);
|
|
cid = kDoubleCid;
|
|
}
|
|
}
|
|
} else {
|
|
// Check if ICDData contains checks with Smi/Null combinations. In that case
|
|
// we can still emit the optimized Smi equality operation but need to add
|
|
// checks for null or Smi.
|
|
if (binary_feedback.OperandsAreSmiOrNull()) {
|
|
AddChecksForArgNr(call, left, /* arg_number = */ 0);
|
|
AddChecksForArgNr(call, right, /* arg_number = */ 1);
|
|
|
|
cid = kSmiCid;
|
|
} else {
|
|
// Shortcut for equality with null.
|
|
// TODO(vegorov): this optimization is not speculative and should
|
|
// be hoisted out of this function.
|
|
ConstantInstr* right_const = right->AsConstant();
|
|
ConstantInstr* left_const = left->AsConstant();
|
|
if ((right_const != NULL && right_const->value().IsNull()) ||
|
|
(left_const != NULL && left_const->value().IsNull())) {
|
|
StrictCompareInstr* comp = new (Z)
|
|
StrictCompareInstr(call->source(), Token::kEQ_STRICT,
|
|
new (Z) Value(left), new (Z) Value(right),
|
|
/* number_check = */ false, DeoptId::kNone);
|
|
ReplaceCall(call, comp);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
ASSERT(cid != kIllegalCid);
|
|
EqualityCompareInstr* comp =
|
|
new (Z) EqualityCompareInstr(call->source(), op_kind, new (Z) Value(left),
|
|
new (Z) Value(right), cid, call->deopt_id());
|
|
ReplaceCall(call, comp);
|
|
return true;
|
|
}
|
|
|
|
bool CallSpecializer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
|
|
Token::Kind op_kind) {
|
|
ASSERT(call->type_args_len() == 0);
|
|
ASSERT(call->ArgumentCount() == 2);
|
|
|
|
const BinaryFeedback& binary_feedback = call->BinaryFeedback();
|
|
Definition* left = call->ArgumentAt(0);
|
|
Definition* right = call->ArgumentAt(1);
|
|
|
|
intptr_t cid = kIllegalCid;
|
|
if (binary_feedback.OperandsAre(kSmiCid)) {
|
|
InsertBefore(call,
|
|
new (Z) CheckSmiInstr(new (Z) Value(left), call->deopt_id(),
|
|
call->source()),
|
|
call->env(), FlowGraph::kEffect);
|
|
InsertBefore(call,
|
|
new (Z) CheckSmiInstr(new (Z) Value(right), call->deopt_id(),
|
|
call->source()),
|
|
call->env(), FlowGraph::kEffect);
|
|
cid = kSmiCid;
|
|
} else if (binary_feedback.OperandsAreSmiOrMint()) {
|
|
cid = kMintCid;
|
|
} else if (binary_feedback.OperandsAreSmiOrDouble() && CanUnboxDouble()) {
|
|
// Use double comparison.
|
|
if (SmiFitsInDouble()) {
|
|
cid = kDoubleCid;
|
|
} else {
|
|
if (binary_feedback.IncludesOperands(kSmiCid)) {
|
|
// We cannot use double comparison on two smis. Need polymorphic
|
|
// call.
|
|
return false;
|
|
} else {
|
|
InsertBefore(
|
|
call,
|
|
new (Z) CheckEitherNonSmiInstr(
|
|
new (Z) Value(left), new (Z) Value(right), call->deopt_id()),
|
|
call->env(), FlowGraph::kEffect);
|
|
cid = kDoubleCid;
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
ASSERT(cid != kIllegalCid);
|
|
RelationalOpInstr* comp =
|
|
new (Z) RelationalOpInstr(call->source(), op_kind, new (Z) Value(left),
|
|
new (Z) Value(right), cid, call->deopt_id());
|
|
ReplaceCall(call, comp);
|
|
return true;
|
|
}
|
|
|
|
bool CallSpecializer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
|
|
Token::Kind op_kind) {
|
|
intptr_t operands_type = kIllegalCid;
|
|
ASSERT(call->HasICData());
|
|
const BinaryFeedback& binary_feedback = call->BinaryFeedback();
|
|
switch (op_kind) {
|
|
case Token::kADD:
|
|
case Token::kSUB:
|
|
case Token::kMUL:
|
|
if (binary_feedback.OperandsAre(kSmiCid)) {
|
|
// Don't generate smi code if the IC data is marked because
|
|
// of an overflow.
|
|
operands_type =
|
|
call->ic_data()->HasDeoptReason(ICData::kDeoptBinarySmiOp)
|
|
? kMintCid
|
|
: kSmiCid;
|
|
} else if (binary_feedback.OperandsAreSmiOrMint()) {
|
|
// Don't generate mint code if the IC data is marked because of an
|
|
// overflow.
|
|
if (call->ic_data()->HasDeoptReason(ICData::kDeoptBinaryInt64Op))
|
|
return false;
|
|
operands_type = kMintCid;
|
|
} else if (ShouldSpecializeForDouble(binary_feedback)) {
|
|
operands_type = kDoubleCid;
|
|
} else if (binary_feedback.OperandsAre(kFloat32x4Cid)) {
|
|
operands_type = kFloat32x4Cid;
|
|
} else if (binary_feedback.OperandsAre(kInt32x4Cid)) {
|
|
ASSERT(op_kind != Token::kMUL); // Int32x4 doesn't have a multiply op.
|
|
operands_type = kInt32x4Cid;
|
|
} else if (binary_feedback.OperandsAre(kFloat64x2Cid)) {
|
|
operands_type = kFloat64x2Cid;
|
|
} else {
|
|
return false;
|
|
}
|
|
break;
|
|
case Token::kDIV:
|
|
if (ShouldSpecializeForDouble(binary_feedback) ||
|
|
binary_feedback.OperandsAre(kSmiCid)) {
|
|
operands_type = kDoubleCid;
|
|
} else if (binary_feedback.OperandsAre(kFloat32x4Cid)) {
|
|
operands_type = kFloat32x4Cid;
|
|
} else if (binary_feedback.OperandsAre(kFloat64x2Cid)) {
|
|
operands_type = kFloat64x2Cid;
|
|
} else {
|
|
return false;
|
|
}
|
|
break;
|
|
case Token::kBIT_AND:
|
|
case Token::kBIT_OR:
|
|
case Token::kBIT_XOR:
|
|
if (binary_feedback.OperandsAre(kSmiCid)) {
|
|
operands_type = kSmiCid;
|
|
} else if (binary_feedback.OperandsAreSmiOrMint()) {
|
|
operands_type = kMintCid;
|
|
} else if (binary_feedback.OperandsAre(kInt32x4Cid)) {
|
|
operands_type = kInt32x4Cid;
|
|
} else {
|
|
return false;
|
|
}
|
|
break;
|
|
case Token::kSHL:
|
|
case Token::kSHR:
|
|
case Token::kUSHR:
|
|
if (binary_feedback.OperandsAre(kSmiCid)) {
|
|
// Left shift may overflow from smi into mint.
|
|
// Don't generate smi code if the IC data is marked because
|
|
// of an overflow.
|
|
if (call->ic_data()->HasDeoptReason(ICData::kDeoptBinaryInt64Op)) {
|
|
return false;
|
|
}
|
|
operands_type =
|
|
call->ic_data()->HasDeoptReason(ICData::kDeoptBinarySmiOp)
|
|
? kMintCid
|
|
: kSmiCid;
|
|
} else if (binary_feedback.OperandsAreSmiOrMint() &&
|
|
binary_feedback.ArgumentIs(kSmiCid)) {
|
|
// Don't generate mint code if the IC data is marked because of an
|
|
// overflow.
|
|
if (call->ic_data()->HasDeoptReason(ICData::kDeoptBinaryInt64Op)) {
|
|
return false;
|
|
}
|
|
// Check for smi/mint << smi or smi/mint >> smi.
|
|
operands_type = kMintCid;
|
|
} else {
|
|
return false;
|
|
}
|
|
break;
|
|
case Token::kMOD:
|
|
case Token::kTRUNCDIV:
|
|
if (binary_feedback.OperandsAre(kSmiCid)) {
|
|
if (call->ic_data()->HasDeoptReason(ICData::kDeoptBinarySmiOp)) {
|
|
return false;
|
|
}
|
|
operands_type = kSmiCid;
|
|
} else {
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
|
|
ASSERT(call->type_args_len() == 0);
|
|
ASSERT(call->ArgumentCount() == 2);
|
|
Definition* left = call->ArgumentAt(0);
|
|
Definition* right = call->ArgumentAt(1);
|
|
if (operands_type == kDoubleCid) {
|
|
if (!CanUnboxDouble()) {
|
|
return false;
|
|
}
|
|
// Check that either left or right are not a smi. Result of a
|
|
// binary operation with two smis is a smi not a double, except '/' which
|
|
// returns a double for two smis.
|
|
if (op_kind != Token::kDIV) {
|
|
InsertBefore(
|
|
call,
|
|
new (Z) CheckEitherNonSmiInstr(
|
|
new (Z) Value(left), new (Z) Value(right), call->deopt_id()),
|
|
call->env(), FlowGraph::kEffect);
|
|
}
|
|
|
|
BinaryDoubleOpInstr* double_bin_op = new (Z)
|
|
BinaryDoubleOpInstr(op_kind, new (Z) Value(left), new (Z) Value(right),
|
|
call->deopt_id(), call->source());
|
|
ReplaceCall(call, double_bin_op);
|
|
} else if (operands_type == kMintCid) {
|
|
if ((op_kind == Token::kSHL) || (op_kind == Token::kSHR) ||
|
|
(op_kind == Token::kUSHR)) {
|
|
SpeculativeShiftInt64OpInstr* shift_op = new (Z)
|
|
SpeculativeShiftInt64OpInstr(op_kind, new (Z) Value(left),
|
|
new (Z) Value(right), call->deopt_id());
|
|
ReplaceCall(call, shift_op);
|
|
} else {
|
|
BinaryInt64OpInstr* bin_op = new (Z) BinaryInt64OpInstr(
|
|
op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
|
|
ReplaceCall(call, bin_op);
|
|
}
|
|
} else if ((operands_type == kFloat32x4Cid) ||
|
|
(operands_type == kInt32x4Cid) ||
|
|
(operands_type == kFloat64x2Cid)) {
|
|
return InlineSimdBinaryOp(call, operands_type, op_kind);
|
|
} else if (op_kind == Token::kMOD) {
|
|
ASSERT(operands_type == kSmiCid);
|
|
if (right->IsConstant()) {
|
|
const Object& obj = right->AsConstant()->value();
|
|
if (obj.IsSmi() && Utils::IsPowerOfTwo(Smi::Cast(obj).Value())) {
|
|
// Insert smi check and attach a copy of the original environment
|
|
// because the smi operation can still deoptimize.
|
|
InsertBefore(call,
|
|
new (Z) CheckSmiInstr(new (Z) Value(left),
|
|
call->deopt_id(), call->source()),
|
|
call->env(), FlowGraph::kEffect);
|
|
ConstantInstr* constant = flow_graph()->GetConstant(
|
|
Smi::Handle(Z, Smi::New(Smi::Cast(obj).Value() - 1)));
|
|
BinarySmiOpInstr* bin_op =
|
|
new (Z) BinarySmiOpInstr(Token::kBIT_AND, new (Z) Value(left),
|
|
new (Z) Value(constant), call->deopt_id());
|
|
ReplaceCall(call, bin_op);
|
|
return true;
|
|
}
|
|
}
|
|
// Insert two smi checks and attach a copy of the original
|
|
// environment because the smi operation can still deoptimize.
|
|
AddCheckSmi(left, call->deopt_id(), call->env(), call);
|
|
AddCheckSmi(right, call->deopt_id(), call->env(), call);
|
|
BinarySmiOpInstr* bin_op = new (Z) BinarySmiOpInstr(
|
|
op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
|
|
ReplaceCall(call, bin_op);
|
|
} else {
|
|
ASSERT(operands_type == kSmiCid);
|
|
// Insert two smi checks and attach a copy of the original
|
|
// environment because the smi operation can still deoptimize.
|
|
AddCheckSmi(left, call->deopt_id(), call->env(), call);
|
|
AddCheckSmi(right, call->deopt_id(), call->env(), call);
|
|
if (left->IsConstant() &&
|
|
((op_kind == Token::kADD) || (op_kind == Token::kMUL))) {
|
|
// Constant should be on the right side.
|
|
Definition* temp = left;
|
|
left = right;
|
|
right = temp;
|
|
}
|
|
BinarySmiOpInstr* bin_op = new (Z) BinarySmiOpInstr(
|
|
op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
|
|
ReplaceCall(call, bin_op);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CallSpecializer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
|
|
Token::Kind op_kind) {
|
|
ASSERT(call->type_args_len() == 0);
|
|
ASSERT(call->ArgumentCount() == 1);
|
|
Definition* input = call->ArgumentAt(0);
|
|
Definition* unary_op = NULL;
|
|
if (call->Targets().ReceiverIs(kSmiCid)) {
|
|
InsertBefore(call,
|
|
new (Z) CheckSmiInstr(new (Z) Value(input), call->deopt_id(),
|
|
call->source()),
|
|
call->env(), FlowGraph::kEffect);
|
|
unary_op = new (Z)
|
|
UnarySmiOpInstr(op_kind, new (Z) Value(input), call->deopt_id());
|
|
} else if ((op_kind == Token::kBIT_NOT) &&
|
|
call->Targets().ReceiverIsSmiOrMint()) {
|
|
unary_op = new (Z)
|
|
UnaryInt64OpInstr(op_kind, new (Z) Value(input), call->deopt_id());
|
|
} else if (call->Targets().ReceiverIs(kDoubleCid) &&
|
|
(op_kind == Token::kNEGATE) && CanUnboxDouble()) {
|
|
AddReceiverCheck(call);
|
|
unary_op = new (Z) UnaryDoubleOpInstr(Token::kNEGATE, new (Z) Value(input),
|
|
call->deopt_id());
|
|
} else {
|
|
return false;
|
|
}
|
|
ASSERT(unary_op != NULL);
|
|
ReplaceCall(call, unary_op);
|
|
return true;
|
|
}
|
|
|
|
bool CallSpecializer::TryInlineImplicitInstanceGetter(InstanceCallInstr* call) {
|
|
const CallTargets& targets = call->Targets();
|
|
ASSERT(targets.HasSingleTarget());
|
|
|
|
// Inline implicit instance getter.
|
|
Field& field = Field::ZoneHandle(Z, targets.FirstTarget().accessor_field());
|
|
ASSERT(!field.IsNull());
|
|
if (field.needs_load_guard()) {
|
|
return false;
|
|
}
|
|
if (should_clone_fields_) {
|
|
field = field.CloneFromOriginal();
|
|
}
|
|
|
|
switch (flow_graph()->CheckForInstanceCall(
|
|
call, UntaggedFunction::kImplicitGetter)) {
|
|
case FlowGraph::ToCheck::kCheckNull:
|
|
AddCheckNull(call->Receiver(), call->function_name(), call->deopt_id(),
|
|
call->env(), call);
|
|
break;
|
|
case FlowGraph::ToCheck::kCheckCid:
|
|
if (CompilerState::Current().is_aot()) {
|
|
return false; // AOT cannot class check
|
|
}
|
|
AddReceiverCheck(call);
|
|
break;
|
|
case FlowGraph::ToCheck::kNoCheck:
|
|
break;
|
|
}
|
|
InlineImplicitInstanceGetter(call, field);
|
|
return true;
|
|
}
|
|
|
|
void CallSpecializer::InlineImplicitInstanceGetter(Definition* call,
|
|
const Field& field) {
|
|
ASSERT(field.is_instance());
|
|
Definition* receiver = call->ArgumentAt(0);
|
|
|
|
const bool calls_initializer = field.NeedsInitializationCheckOnLoad();
|
|
const Slot& slot = Slot::Get(field, &flow_graph()->parsed_function());
|
|
LoadFieldInstr* load = new (Z) LoadFieldInstr(
|
|
new (Z) Value(receiver), slot, call->source(), calls_initializer,
|
|
calls_initializer ? call->deopt_id() : DeoptId::kNone);
|
|
|
|
// Note that this is a case of LoadField -> InstanceCall lazy deopt.
|
|
// Which means that we don't need to remove arguments from the environment
|
|
// because normal getter call expects receiver pushed (unlike the case
|
|
// of LoadField -> LoadField deoptimization handled by
|
|
// FlowGraph::AttachEnvironment).
|
|
if (!calls_initializer) {
|
|
// If we don't call initializer then we don't need an environment.
|
|
call->RemoveEnvironment();
|
|
}
|
|
ReplaceCall(call, load);
|
|
|
|
if (load->slot().nullable_cid() != kDynamicCid) {
|
|
// Reset value types if we know concrete cid.
|
|
for (Value::Iterator it(load->input_use_list()); !it.Done(); it.Advance()) {
|
|
it.Current()->SetReachingType(nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CallSpecializer::TryInlineInstanceSetter(InstanceCallInstr* instr) {
|
|
const CallTargets& targets = instr->Targets();
|
|
if (!targets.HasSingleTarget()) {
|
|
// Polymorphic sites are inlined like normal method calls by conventional
|
|
// inlining.
|
|
return false;
|
|
}
|
|
const Function& target = targets.FirstTarget();
|
|
if (target.kind() != UntaggedFunction::kImplicitSetter) {
|
|
// Non-implicit setter are inlined like normal method calls.
|
|
return false;
|
|
}
|
|
if (!CompilerState::Current().is_aot() && !target.WasCompiled()) {
|
|
return false;
|
|
}
|
|
Field& field = Field::ZoneHandle(Z, target.accessor_field());
|
|
ASSERT(!field.IsNull());
|
|
if (should_clone_fields_) {
|
|
field = field.CloneFromOriginal();
|
|
}
|
|
|
|
switch (flow_graph()->CheckForInstanceCall(
|
|
instr, UntaggedFunction::kImplicitSetter)) {
|
|
case FlowGraph::ToCheck::kCheckNull:
|
|
AddCheckNull(instr->Receiver(), instr->function_name(), instr->deopt_id(),
|
|
instr->env(), instr);
|
|
break;
|
|
case FlowGraph::ToCheck::kCheckCid:
|
|
if (CompilerState::Current().is_aot()) {
|
|
return false; // AOT cannot class check
|
|
}
|
|
AddReceiverCheck(instr);
|
|
break;
|
|
case FlowGraph::ToCheck::kNoCheck:
|
|
break;
|
|
}
|
|
|
|
// True if we can use unchecked entry into the setter.
|
|
bool is_unchecked_call = false;
|
|
if (!CompilerState::Current().is_aot()) {
|
|
if (targets.IsMonomorphic() && targets.MonomorphicExactness().IsExact()) {
|
|
if (targets.MonomorphicExactness().IsTriviallyExact()) {
|
|
flow_graph()->AddExactnessGuard(instr,
|
|
targets.MonomorphicReceiverCid());
|
|
}
|
|
is_unchecked_call = true;
|
|
}
|
|
}
|
|
|
|
if (IG->use_field_guards()) {
|
|
if (field.guarded_cid() != kDynamicCid) {
|
|
InsertSpeculativeBefore(
|
|
instr,
|
|
new (Z) GuardFieldClassInstr(new (Z) Value(instr->ArgumentAt(1)),
|
|
field, instr->deopt_id()),
|
|
instr->env(), FlowGraph::kEffect);
|
|
}
|
|
|
|
if (field.needs_length_check()) {
|
|
InsertSpeculativeBefore(
|
|
instr,
|
|
new (Z) GuardFieldLengthInstr(new (Z) Value(instr->ArgumentAt(1)),
|
|
field, instr->deopt_id()),
|
|
instr->env(), FlowGraph::kEffect);
|
|
}
|
|
|
|
if (field.static_type_exactness_state().NeedsFieldGuard()) {
|
|
InsertSpeculativeBefore(
|
|
instr,
|
|
new (Z) GuardFieldTypeInstr(new (Z) Value(instr->ArgumentAt(1)),
|
|
field, instr->deopt_id()),
|
|
instr->env(), FlowGraph::kEffect);
|
|
}
|
|
}
|
|
|
|
// Build an AssertAssignable if necessary.
|
|
const AbstractType& dst_type = AbstractType::ZoneHandle(zone(), field.type());
|
|
if (!dst_type.IsTopTypeForSubtyping()) {
|
|
// Compute if we need to type check the value. Always type check if
|
|
// at a dynamic invocation.
|
|
bool needs_check = true;
|
|
if (!instr->interface_target().IsNull()) {
|
|
if (field.is_covariant()) {
|
|
// Always type check covariant fields.
|
|
needs_check = true;
|
|
} else if (field.is_generic_covariant_impl()) {
|
|
// If field is generic covariant then we don't need to check it
|
|
// if the invocation was marked as unchecked (e.g. receiver of
|
|
// the invocation is also the receiver of the surrounding method).
|
|
// Note: we can't use flow_graph()->IsReceiver() for this optimization
|
|
// because strong mode only gives static guarantees at the AST level
|
|
// not at the SSA level.
|
|
needs_check = !(is_unchecked_call ||
|
|
(instr->entry_kind() == Code::EntryKind::kUnchecked));
|
|
} else {
|
|
// The rest of the stores are checked statically (we are not at
|
|
// a dynamic invocation).
|
|
needs_check = false;
|
|
}
|
|
}
|
|
|
|
if (needs_check) {
|
|
Definition* instantiator_type_args = flow_graph_->constant_null();
|
|
Definition* function_type_args = flow_graph_->constant_null();
|
|
if (!dst_type.IsInstantiated()) {
|
|
const Class& owner = Class::Handle(Z, field.Owner());
|
|
if (owner.NumTypeArguments() > 0) {
|
|
instantiator_type_args = new (Z) LoadFieldInstr(
|
|
new (Z) Value(instr->ArgumentAt(0)),
|
|
Slot::GetTypeArgumentsSlotFor(thread(), owner), instr->source());
|
|
InsertSpeculativeBefore(instr, instantiator_type_args, instr->env(),
|
|
FlowGraph::kValue);
|
|
}
|
|
}
|
|
|
|
auto assert_assignable = new (Z) AssertAssignableInstr(
|
|
instr->source(), new (Z) Value(instr->ArgumentAt(1)),
|
|
new (Z) Value(flow_graph_->GetConstant(dst_type)),
|
|
new (Z) Value(instantiator_type_args),
|
|
new (Z) Value(function_type_args),
|
|
String::ZoneHandle(zone(), field.name()), instr->deopt_id());
|
|
InsertSpeculativeBefore(instr, assert_assignable, instr->env(),
|
|
FlowGraph::kEffect);
|
|
}
|
|
}
|
|
|
|
// Field guard was detached.
|
|
ASSERT(instr->FirstArgIndex() == 0);
|
|
StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
|
|
field, new (Z) Value(instr->ArgumentAt(0)),
|
|
new (Z) Value(instr->ArgumentAt(1)), kEmitStoreBarrier, instr->source(),
|
|
&flow_graph()->parsed_function());
|
|
|
|
// Discard the environment from the original instruction because the store
|
|
// can't deoptimize.
|
|
instr->RemoveEnvironment();
|
|
ReplaceCallWithResult(instr, store, flow_graph()->constant_null());
|
|
return true;
|
|
}
|
|
|
|
bool CallSpecializer::InlineSimdBinaryOp(InstanceCallInstr* call,
|
|
intptr_t cid,
|
|
Token::Kind op_kind) {
|
|
if (!ShouldInlineSimd()) {
|
|
return false;
|
|
}
|
|
ASSERT(call->type_args_len() == 0);
|
|
ASSERT(call->ArgumentCount() == 2);
|
|
Definition* const left = call->ArgumentAt(0);
|
|
Definition* const right = call->ArgumentAt(1);
|
|
// Type check left and right.
|
|
AddChecksForArgNr(call, left, /* arg_number = */ 0);
|
|
AddChecksForArgNr(call, right, /* arg_number = */ 1);
|
|
// Replace call.
|
|
SimdOpInstr* op = SimdOpInstr::Create(
|
|
SimdOpInstr::KindForOperator(cid, op_kind), new (Z) Value(left),
|
|
new (Z) Value(right), call->deopt_id());
|
|
ReplaceCall(call, op);
|
|
|
|
return true;
|
|
}
|
|
|
|
// Only unique implicit instance getters can be currently handled.
|
|
bool CallSpecializer::TryInlineInstanceGetter(InstanceCallInstr* call) {
|
|
const CallTargets& targets = call->Targets();
|
|
if (!targets.HasSingleTarget()) {
|
|
// Polymorphic sites are inlined like normal methods by conventional
|
|
// inlining in FlowGraphInliner.
|
|
return false;
|
|
}
|
|
const Function& target = targets.FirstTarget();
|
|
if (target.kind() != UntaggedFunction::kImplicitGetter) {
|
|
// Non-implicit getters are inlined like normal methods by conventional
|
|
// inlining in FlowGraphInliner.
|
|
return false;
|
|
}
|
|
if (!CompilerState::Current().is_aot() && !target.WasCompiled()) {
|
|
return false;
|
|
}
|
|
return TryInlineImplicitInstanceGetter(call);
|
|
}
|
|
|
|
// Inline only simple, frequently called core library methods.
|
|
bool CallSpecializer::TryInlineInstanceMethod(InstanceCallInstr* call) {
|
|
const CallTargets& targets = call->Targets();
|
|
if (!targets.IsMonomorphic()) {
|
|
// No type feedback collected or multiple receivers/targets found.
|
|
return false;
|
|
}
|
|
|
|
const Function& target = targets.FirstTarget();
|
|
intptr_t receiver_cid = targets.MonomorphicReceiverCid();
|
|
MethodRecognizer::Kind recognized_kind = target.recognized_kind();
|
|
|
|
if (CanUnboxDouble() &&
|
|
(recognized_kind == MethodRecognizer::kIntegerToDouble)) {
|
|
if (receiver_cid == kSmiCid) {
|
|
AddReceiverCheck(call);
|
|
ReplaceCall(call,
|
|
new (Z) SmiToDoubleInstr(new (Z) Value(call->ArgumentAt(0)),
|
|
call->source()));
|
|
return true;
|
|
} else if ((receiver_cid == kMintCid) && CanConvertInt64ToDouble()) {
|
|
AddReceiverCheck(call);
|
|
ReplaceCall(call,
|
|
new (Z) Int64ToDoubleInstr(new (Z) Value(call->ArgumentAt(0)),
|
|
call->deopt_id()));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (receiver_cid == kDoubleCid) {
|
|
if (!CanUnboxDouble()) {
|
|
return false;
|
|
}
|
|
switch (recognized_kind) {
|
|
case MethodRecognizer::kDoubleToInteger: {
|
|
AddReceiverCheck(call);
|
|
ASSERT(call->HasICData());
|
|
const ICData& ic_data = *call->ic_data();
|
|
Definition* input = call->ArgumentAt(0);
|
|
Definition* d2i_instr = NULL;
|
|
if (ic_data.HasDeoptReason(ICData::kDeoptDoubleToSmi)) {
|
|
// Do not repeatedly deoptimize because result didn't fit into Smi.
|
|
d2i_instr = new (Z) DoubleToIntegerInstr(
|
|
new (Z) Value(input), recognized_kind, call->deopt_id());
|
|
} else {
|
|
// Optimistically assume result fits into Smi.
|
|
d2i_instr =
|
|
new (Z) DoubleToSmiInstr(new (Z) Value(input), call->deopt_id());
|
|
}
|
|
ReplaceCall(call, d2i_instr);
|
|
return true;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return FlowGraphInliner::TryReplaceInstanceCallWithInline(
|
|
flow_graph_, current_iterator(), call, speculative_policy_);
|
|
}
|
|
|
|
// If type tests specified by 'ic_data' do not depend on type arguments,
|
|
// return mapping cid->result in 'results' (i : cid; i + 1: result).
|
|
// If all tests yield the same result, return it otherwise return Bool::null.
|
|
// If no mapping is possible, 'results' has less than
|
|
// (ic_data.NumberOfChecks() * 2) entries
|
|
// An instance-of test returning all same results can be converted to a class
|
|
// check.
|
|
BoolPtr CallSpecializer::InstanceOfAsBool(
|
|
const ICData& ic_data,
|
|
const AbstractType& type,
|
|
ZoneGrowableArray<intptr_t>* results) const {
|
|
ASSERT(results->is_empty());
|
|
ASSERT(ic_data.NumArgsTested() == 1); // Unary checks only.
|
|
if (type.IsFunctionType() || type.IsDartFunctionType() ||
|
|
!type.IsInstantiated()) {
|
|
return Bool::null();
|
|
}
|
|
const Class& type_class = Class::Handle(Z, type.type_class());
|
|
const intptr_t num_type_args = type_class.NumTypeArguments();
|
|
if (num_type_args > 0) {
|
|
// Only raw types can be directly compared, thus disregarding type
|
|
// arguments.
|
|
const intptr_t num_type_params = type_class.NumTypeParameters();
|
|
const intptr_t from_index = num_type_args - num_type_params;
|
|
const TypeArguments& type_arguments =
|
|
TypeArguments::Handle(Z, type.arguments());
|
|
const bool is_raw_type = type_arguments.IsNull() ||
|
|
type_arguments.IsRaw(from_index, num_type_params);
|
|
if (!is_raw_type) {
|
|
// Unknown result.
|
|
return Bool::null();
|
|
}
|
|
}
|
|
|
|
const ClassTable& class_table = *IG->class_table();
|
|
Bool& prev = Bool::Handle(Z);
|
|
Class& cls = Class::Handle(Z);
|
|
|
|
bool results_differ = false;
|
|
const intptr_t number_of_checks = ic_data.NumberOfChecks();
|
|
for (int i = 0; i < number_of_checks; i++) {
|
|
cls = class_table.At(ic_data.GetReceiverClassIdAt(i));
|
|
if (cls.NumTypeArguments() > 0) {
|
|
return Bool::null();
|
|
}
|
|
bool is_subtype = false;
|
|
if (cls.IsNullClass()) {
|
|
// 'null' is an instance of Null, Object*, Never*, void, and dynamic.
|
|
// In addition, 'null' is an instance of any nullable type.
|
|
// It is also an instance of FutureOr<T> if it is an instance of T.
|
|
const AbstractType& unwrapped_type =
|
|
AbstractType::Handle(type.UnwrapFutureOr());
|
|
ASSERT(unwrapped_type.IsInstantiated());
|
|
is_subtype = unwrapped_type.IsTopTypeForInstanceOf() ||
|
|
unwrapped_type.IsNullable() ||
|
|
(unwrapped_type.IsLegacy() && unwrapped_type.IsNeverType());
|
|
} else {
|
|
is_subtype =
|
|
Class::IsSubtypeOf(cls, Object::null_type_arguments(),
|
|
Nullability::kNonNullable, type, Heap::kOld);
|
|
}
|
|
results->Add(cls.id());
|
|
results->Add(static_cast<intptr_t>(is_subtype));
|
|
if (prev.IsNull()) {
|
|
prev = Bool::Get(is_subtype).ptr();
|
|
} else {
|
|
if (is_subtype != prev.value()) {
|
|
results_differ = true;
|
|
}
|
|
}
|
|
}
|
|
return results_differ ? Bool::null() : prev.ptr();
|
|
}
|
|
|
|
// Returns true if checking against this type is a direct class id comparison.
|
|
bool CallSpecializer::TypeCheckAsClassEquality(const AbstractType& type) {
|
|
ASSERT(type.IsFinalized());
|
|
// Requires CHA.
|
|
if (!type.IsInstantiated()) return false;
|
|
// Function types have different type checking rules.
|
|
if (type.IsFunctionType()) return false;
|
|
const Class& type_class = Class::Handle(type.type_class());
|
|
// Could be an interface check?
|
|
if (CHA::IsImplemented(type_class)) return false;
|
|
// Check if there are subclasses.
|
|
if (CHA::HasSubclasses(type_class)) {
|
|
return false;
|
|
}
|
|
|
|
// Private classes cannot be subclassed by later loaded libs.
|
|
if (!type_class.IsPrivate()) {
|
|
// In AOT mode we can't use CHA deoptimizations.
|
|
ASSERT(!CompilerState::Current().is_aot() || !FLAG_use_cha_deopt);
|
|
if (FLAG_use_cha_deopt || isolate_group()->all_classes_finalized()) {
|
|
if (FLAG_trace_cha) {
|
|
THR_Print(
|
|
" **(CHA) Typecheck as class equality since no "
|
|
"subclasses: %s\n",
|
|
type_class.ToCString());
|
|
}
|
|
if (FLAG_use_cha_deopt) {
|
|
thread()->compiler_state().cha().AddToGuardedClasses(
|
|
type_class, /*subclass_count=*/0);
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
const intptr_t num_type_args = type_class.NumTypeArguments();
|
|
if (num_type_args > 0) {
|
|
// Only raw types can be directly compared, thus disregarding type
|
|
// arguments.
|
|
const intptr_t num_type_params = type_class.NumTypeParameters();
|
|
const intptr_t from_index = num_type_args - num_type_params;
|
|
const TypeArguments& type_arguments =
|
|
TypeArguments::Handle(type.arguments());
|
|
const bool is_raw_type = type_arguments.IsNull() ||
|
|
type_arguments.IsRaw(from_index, num_type_params);
|
|
if (!is_raw_type) {
|
|
return false;
|
|
}
|
|
}
|
|
if (type.IsNullable() || type.IsTopTypeForInstanceOf() ||
|
|
type.IsNeverType()) {
|
|
// A class id check is not sufficient, since a null instance also satisfies
|
|
// the test against a nullable type.
|
|
// TODO(regis): Add a null check in addition to the class id check?
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CallSpecializer::TryReplaceInstanceOfWithRangeCheck(
|
|
InstanceCallInstr* call,
|
|
const AbstractType& type) {
|
|
// TODO(dartbug.com/30632) does this optimization make sense in JIT?
|
|
return false;
|
|
}
|
|
|
|
bool CallSpecializer::TryOptimizeInstanceOfUsingStaticTypes(
|
|
InstanceCallInstr* call,
|
|
const AbstractType& type) {
|
|
ASSERT(Token::IsTypeTestOperator(call->token_kind()));
|
|
if (!type.IsInstantiated()) {
|
|
return false;
|
|
}
|
|
|
|
Value* left_value = call->Receiver();
|
|
if (left_value->Type()->IsInstanceOf(type)) {
|
|
ConstantInstr* replacement = flow_graph()->GetConstant(Bool::True());
|
|
call->ReplaceUsesWith(replacement);
|
|
ASSERT(current_iterator()->Current() == call);
|
|
current_iterator()->RemoveCurrentFromGraph();
|
|
return true;
|
|
}
|
|
|
|
// The goal is to emit code that will determine the result of 'x is type'
|
|
// depending solely on the fact that x == null or not.
|
|
// Checking whether the receiver is null can only help if the tested type is
|
|
// non-nullable or legacy (including Never*) or the Null type.
|
|
// Also, testing receiver for null cannot help with FutureOr.
|
|
if ((type.IsNullable() && !type.IsNullType()) || type.IsFutureOrType()) {
|
|
return false;
|
|
}
|
|
|
|
// If type is Null or Never*, or the static type of the receiver is a
|
|
// subtype of the tested type, replace 'receiver is type' with
|
|
// - 'receiver == null' if type is Null or Never*,
|
|
// - 'receiver != null' otherwise.
|
|
if (type.IsNullType() || (type.IsNeverType() && type.IsLegacy()) ||
|
|
left_value->Type()->IsSubtypeOf(type)) {
|
|
Definition* replacement = new (Z) StrictCompareInstr(
|
|
call->source(),
|
|
(type.IsNullType() || (type.IsNeverType() && type.IsLegacy()))
|
|
? Token::kEQ_STRICT
|
|
: Token::kNE_STRICT,
|
|
left_value->CopyWithType(Z),
|
|
new (Z) Value(flow_graph()->constant_null()),
|
|
/* number_check = */ false, DeoptId::kNone);
|
|
if (FLAG_trace_strong_mode_types) {
|
|
THR_Print("[Strong mode] replacing %s with %s (%s < %s)\n",
|
|
call->ToCString(), replacement->ToCString(),
|
|
left_value->Type()->ToAbstractType()->ToCString(),
|
|
type.ToCString());
|
|
}
|
|
ReplaceCall(call, replacement);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CallSpecializer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
|
|
ASSERT(Token::IsTypeTestOperator(call->token_kind()));
|
|
Definition* left = call->ArgumentAt(0);
|
|
Definition* instantiator_type_args = NULL;
|
|
Definition* function_type_args = NULL;
|
|
AbstractType& type = AbstractType::ZoneHandle(Z);
|
|
ASSERT(call->type_args_len() == 0);
|
|
if (call->ArgumentCount() == 2) {
|
|
instantiator_type_args = flow_graph()->constant_null();
|
|
function_type_args = flow_graph()->constant_null();
|
|
ASSERT(call->MatchesCoreName(Symbols::_simpleInstanceOf()));
|
|
type = AbstractType::Cast(call->ArgumentAt(1)->AsConstant()->value()).ptr();
|
|
} else {
|
|
ASSERT(call->ArgumentCount() == 4);
|
|
instantiator_type_args = call->ArgumentAt(1);
|
|
function_type_args = call->ArgumentAt(2);
|
|
type = AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value()).ptr();
|
|
}
|
|
|
|
if (TryOptimizeInstanceOfUsingStaticTypes(call, type)) {
|
|
return;
|
|
}
|
|
|
|
if (TypeCheckAsClassEquality(type)) {
|
|
LoadClassIdInstr* left_cid = new (Z) LoadClassIdInstr(new (Z) Value(left));
|
|
InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
|
|
const intptr_t type_cid = Class::Handle(Z, type.type_class()).id();
|
|
ConstantInstr* cid =
|
|
flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(type_cid)));
|
|
|
|
StrictCompareInstr* check_cid = new (Z) StrictCompareInstr(
|
|
call->source(), Token::kEQ_STRICT, new (Z) Value(left_cid),
|
|
new (Z) Value(cid), /* number_check = */ false, DeoptId::kNone);
|
|
ReplaceCall(call, check_cid);
|
|
return;
|
|
}
|
|
|
|
if (TryReplaceInstanceOfWithRangeCheck(call, type)) {
|
|
return;
|
|
}
|
|
|
|
const ICData& unary_checks =
|
|
ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
|
|
const intptr_t number_of_checks = unary_checks.NumberOfChecks();
|
|
if (number_of_checks > 0 && number_of_checks <= FLAG_max_polymorphic_checks) {
|
|
ZoneGrowableArray<intptr_t>* results =
|
|
new (Z) ZoneGrowableArray<intptr_t>(number_of_checks * 2);
|
|
const Bool& as_bool =
|
|
Bool::ZoneHandle(Z, InstanceOfAsBool(unary_checks, type, results));
|
|
if (as_bool.IsNull() || CompilerState::Current().is_aot()) {
|
|
if (results->length() == number_of_checks * 2) {
|
|
const bool can_deopt = SpecializeTestCidsForNumericTypes(results, type);
|
|
if (can_deopt &&
|
|
!speculative_policy_->IsAllowedForInlining(call->deopt_id())) {
|
|
// Guard against repeated speculative inlining.
|
|
return;
|
|
}
|
|
TestCidsInstr* test_cids = new (Z) TestCidsInstr(
|
|
call->source(), Token::kIS, new (Z) Value(left), *results,
|
|
can_deopt ? call->deopt_id() : DeoptId::kNone);
|
|
// Remove type.
|
|
ReplaceCall(call, test_cids);
|
|
return;
|
|
}
|
|
} else {
|
|
// One result only.
|
|
AddReceiverCheck(call);
|
|
ConstantInstr* bool_const = flow_graph()->GetConstant(as_bool);
|
|
ASSERT(!call->HasPushArguments());
|
|
call->ReplaceUsesWith(bool_const);
|
|
ASSERT(current_iterator()->Current() == call);
|
|
current_iterator()->RemoveCurrentFromGraph();
|
|
return;
|
|
}
|
|
}
|
|
|
|
InstanceOfInstr* instance_of = new (Z) InstanceOfInstr(
|
|
call->source(), new (Z) Value(left),
|
|
new (Z) Value(instantiator_type_args), new (Z) Value(function_type_args),
|
|
type, call->deopt_id());
|
|
ReplaceCall(call, instance_of);
|
|
}
|
|
|
|
void CallSpecializer::VisitStaticCall(StaticCallInstr* call) {
|
|
if (FlowGraphInliner::TryReplaceStaticCallWithInline(
|
|
flow_graph_, current_iterator(), call, speculative_policy_)) {
|
|
return;
|
|
}
|
|
|
|
if (speculative_policy_->IsAllowedForInlining(call->deopt_id())) {
|
|
// Only if speculative inlining is enabled.
|
|
|
|
MethodRecognizer::Kind recognized_kind = call->function().recognized_kind();
|
|
const CallTargets& targets = call->Targets();
|
|
const BinaryFeedback& binary_feedback = call->BinaryFeedback();
|
|
|
|
switch (recognized_kind) {
|
|
case MethodRecognizer::kMathMin:
|
|
case MethodRecognizer::kMathMax: {
|
|
// We can handle only monomorphic min/max call sites with both arguments
|
|
// being either doubles or smis.
|
|
if (CanUnboxDouble() && targets.IsMonomorphic() &&
|
|
(call->FirstArgIndex() == 0)) {
|
|
intptr_t result_cid = kIllegalCid;
|
|
if (binary_feedback.IncludesOperands(kDoubleCid)) {
|
|
result_cid = kDoubleCid;
|
|
} else if (binary_feedback.IncludesOperands(kSmiCid)) {
|
|
result_cid = kSmiCid;
|
|
}
|
|
if (result_cid != kIllegalCid) {
|
|
MathMinMaxInstr* min_max = new (Z) MathMinMaxInstr(
|
|
recognized_kind, new (Z) Value(call->ArgumentAt(0)),
|
|
new (Z) Value(call->ArgumentAt(1)), call->deopt_id(),
|
|
result_cid);
|
|
const Cids* cids = Cids::CreateMonomorphic(Z, result_cid);
|
|
AddCheckClass(min_max->left()->definition(), *cids,
|
|
call->deopt_id(), call->env(), call);
|
|
AddCheckClass(min_max->right()->definition(), *cids,
|
|
call->deopt_id(), call->env(), call);
|
|
ReplaceCall(call, min_max);
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case MethodRecognizer::kDoubleFromInteger: {
|
|
if (call->HasICData() && targets.IsMonomorphic() &&
|
|
(call->FirstArgIndex() == 0)) {
|
|
if (CanUnboxDouble()) {
|
|
if (binary_feedback.ArgumentIs(kSmiCid)) {
|
|
Definition* arg = call->ArgumentAt(1);
|
|
AddCheckSmi(arg, call->deopt_id(), call->env(), call);
|
|
ReplaceCall(call, new (Z) SmiToDoubleInstr(new (Z) Value(arg),
|
|
call->source()));
|
|
return;
|
|
} else if (binary_feedback.ArgumentIs(kMintCid) &&
|
|
CanConvertInt64ToDouble()) {
|
|
Definition* arg = call->ArgumentAt(1);
|
|
ReplaceCall(call, new (Z) Int64ToDoubleInstr(new (Z) Value(arg),
|
|
call->deopt_id()));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (TryOptimizeStaticCallUsingStaticTypes(call)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CallSpecializer::VisitLoadCodeUnits(LoadCodeUnitsInstr* instr) {
|
|
// TODO(zerny): Use kUnboxedUint32 once it is fully supported/optimized.
|
|
#if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
|
|
if (!instr->can_pack_into_smi()) instr->set_representation(kUnboxedInt64);
|
|
#endif
|
|
}
|
|
|
|
static bool CidTestResultsContains(const ZoneGrowableArray<intptr_t>& results,
|
|
intptr_t test_cid) {
|
|
for (intptr_t i = 0; i < results.length(); i += 2) {
|
|
if (results[i] == test_cid) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void TryAddTest(ZoneGrowableArray<intptr_t>* results,
|
|
intptr_t test_cid,
|
|
bool result) {
|
|
if (!CidTestResultsContains(*results, test_cid)) {
|
|
results->Add(test_cid);
|
|
results->Add(static_cast<intptr_t>(result));
|
|
}
|
|
}
|
|
|
|
// Used when we only need the positive result because we return false by
|
|
// default.
|
|
static void PurgeNegativeTestCidsEntries(ZoneGrowableArray<intptr_t>* results) {
|
|
// We can't purge the Smi entry at the beginning since it is used in the
|
|
// Smi check before the Cid is loaded.
|
|
int dest = 2;
|
|
for (intptr_t i = 2; i < results->length(); i += 2) {
|
|
if (results->At(i + 1) != 0) {
|
|
(*results)[dest++] = results->At(i);
|
|
(*results)[dest++] = results->At(i + 1);
|
|
}
|
|
}
|
|
results->SetLength(dest);
|
|
}
|
|
|
|
bool CallSpecializer::SpecializeTestCidsForNumericTypes(
|
|
ZoneGrowableArray<intptr_t>* results,
|
|
const AbstractType& type) {
|
|
ASSERT(results->length() >= 2); // At least on entry.
|
|
const ClassTable& class_table = *IsolateGroup::Current()->class_table();
|
|
if ((*results)[0] != kSmiCid) {
|
|
const Class& smi_class = Class::Handle(class_table.At(kSmiCid));
|
|
const bool smi_is_subtype =
|
|
Class::IsSubtypeOf(smi_class, Object::null_type_arguments(),
|
|
Nullability::kNonNullable, type, Heap::kOld);
|
|
results->Add((*results)[results->length() - 2]);
|
|
results->Add((*results)[results->length() - 2]);
|
|
for (intptr_t i = results->length() - 3; i > 1; --i) {
|
|
(*results)[i] = (*results)[i - 2];
|
|
}
|
|
(*results)[0] = kSmiCid;
|
|
(*results)[1] = static_cast<intptr_t>(smi_is_subtype);
|
|
}
|
|
|
|
ASSERT(type.IsInstantiated());
|
|
ASSERT(results->length() >= 2);
|
|
if (type.IsSmiType()) {
|
|
ASSERT((*results)[0] == kSmiCid);
|
|
PurgeNegativeTestCidsEntries(results);
|
|
return false;
|
|
} else if (type.IsIntType()) {
|
|
ASSERT((*results)[0] == kSmiCid);
|
|
TryAddTest(results, kMintCid, true);
|
|
// Cannot deoptimize since all tests returning true have been added.
|
|
PurgeNegativeTestCidsEntries(results);
|
|
return false;
|
|
} else if (type.IsNumberType()) {
|
|
ASSERT((*results)[0] == kSmiCid);
|
|
TryAddTest(results, kMintCid, true);
|
|
TryAddTest(results, kDoubleCid, true);
|
|
PurgeNegativeTestCidsEntries(results);
|
|
return false;
|
|
} else if (type.IsDoubleType()) {
|
|
ASSERT((*results)[0] == kSmiCid);
|
|
TryAddTest(results, kDoubleCid, true);
|
|
PurgeNegativeTestCidsEntries(results);
|
|
return false;
|
|
}
|
|
return true; // May deoptimize since we have not identified all 'true' tests.
|
|
}
|
|
|
|
void TypedDataSpecializer::Optimize(FlowGraph* flow_graph) {
|
|
TypedDataSpecializer optimizer(flow_graph);
|
|
optimizer.VisitBlocks();
|
|
}
|
|
|
|
void TypedDataSpecializer::EnsureIsInitialized() {
|
|
if (initialized_) return;
|
|
|
|
initialized_ = true;
|
|
|
|
int_type_ = Type::IntType();
|
|
double_type_ = Type::Double();
|
|
|
|
const auto& typed_data = Library::Handle(
|
|
Z, Library::LookupLibrary(thread_, Symbols::DartTypedData()));
|
|
|
|
auto& td_class = Class::Handle(Z);
|
|
auto& direct_implementors = GrowableObjectArray::Handle(Z);
|
|
SafepointReadRwLocker ml(thread_, thread_->isolate_group()->program_lock());
|
|
|
|
#define INIT_HANDLE(iface, member_name, type, cid) \
|
|
td_class = typed_data.LookupClass(Symbols::iface()); \
|
|
ASSERT(!td_class.IsNull()); \
|
|
direct_implementors = td_class.direct_implementors(); \
|
|
if (!HasThirdPartyImplementor(direct_implementors)) { \
|
|
member_name = td_class.RareType(); \
|
|
}
|
|
|
|
PUBLIC_TYPED_DATA_CLASS_LIST(INIT_HANDLE)
|
|
#undef INIT_HANDLE
|
|
}
|
|
|
|
bool TypedDataSpecializer::HasThirdPartyImplementor(
|
|
const GrowableObjectArray& direct_implementors) {
|
|
// Check if there are non internal/external/view implementors.
|
|
for (intptr_t i = 0; i < direct_implementors.Length(); ++i) {
|
|
implementor_ ^= direct_implementors.At(i);
|
|
|
|
// We only consider [implementor_] a 3rd party implementor if it was
|
|
// finalized by the class finalizer, since only then can we have concrete
|
|
// instances of the [implementor_].
|
|
if (implementor_.is_finalized()) {
|
|
const classid_t cid = implementor_.id();
|
|
if (!IsTypedDataClassId(cid) && !IsTypedDataViewClassId(cid) &&
|
|
!IsExternalTypedDataClassId(cid)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void TypedDataSpecializer::VisitInstanceCall(InstanceCallInstr* call) {
|
|
TryInlineCall(call);
|
|
}
|
|
|
|
void TypedDataSpecializer::VisitStaticCall(StaticCallInstr* call) {
|
|
const Function& function = call->function();
|
|
if (!function.is_static()) {
|
|
ASSERT(call->ArgumentCount() > 0);
|
|
TryInlineCall(call);
|
|
}
|
|
}
|
|
|
|
void TypedDataSpecializer::TryInlineCall(TemplateDartCall<0>* call) {
|
|
const bool is_length_getter = call->Selector() == Symbols::GetLength().ptr();
|
|
const bool is_index_get = call->Selector() == Symbols::IndexToken().ptr();
|
|
const bool is_index_set =
|
|
call->Selector() == Symbols::AssignIndexToken().ptr();
|
|
|
|
if (is_length_getter || is_index_get || is_index_set) {
|
|
EnsureIsInitialized();
|
|
|
|
const intptr_t receiver_index = call->FirstArgIndex();
|
|
|
|
CompileType* receiver_type =
|
|
call->ArgumentValueAt(receiver_index + 0)->Type();
|
|
|
|
CompileType* index_type = nullptr;
|
|
if (is_index_get || is_index_set) {
|
|
index_type = call->ArgumentValueAt(receiver_index + 1)->Type();
|
|
}
|
|
|
|
CompileType* value_type = nullptr;
|
|
if (is_index_set) {
|
|
value_type = call->ArgumentValueAt(receiver_index + 2)->Type();
|
|
}
|
|
|
|
auto& type_class = Class::Handle(zone_);
|
|
#define TRY_INLINE(iface, member_name, type, cid) \
|
|
if (!member_name.IsNull()) { \
|
|
const bool is_float_access = \
|
|
cid == kTypedDataFloat32ArrayCid || cid == kTypedDataFloat64ArrayCid; \
|
|
if (receiver_type->IsAssignableTo(member_name)) { \
|
|
if (is_length_getter) { \
|
|
type_class = member_name.type_class(); \
|
|
ReplaceWithLengthGetter(call); \
|
|
} else if (is_index_get) { \
|
|
if (is_float_access && !FlowGraphCompiler::SupportsUnboxedDoubles()) { \
|
|
return; \
|
|
} \
|
|
if (!index_type->IsNullableInt()) return; \
|
|
type_class = member_name.type_class(); \
|
|
ReplaceWithIndexGet(call, cid); \
|
|
} else { \
|
|
if (is_float_access && !FlowGraphCompiler::SupportsUnboxedDoubles()) { \
|
|
return; \
|
|
} \
|
|
if (!index_type->IsNullableInt()) return; \
|
|
if (!value_type->IsAssignableTo(type)) return; \
|
|
type_class = member_name.type_class(); \
|
|
ReplaceWithIndexSet(call, cid); \
|
|
} \
|
|
return; \
|
|
} \
|
|
}
|
|
PUBLIC_TYPED_DATA_CLASS_LIST(TRY_INLINE)
|
|
#undef INIT_HANDLE
|
|
}
|
|
}
|
|
|
|
void TypedDataSpecializer::ReplaceWithLengthGetter(TemplateDartCall<0>* call) {
|
|
const intptr_t receiver_idx = call->FirstArgIndex();
|
|
auto array = call->ArgumentAt(receiver_idx + 0);
|
|
|
|
if (array->Type()->is_nullable()) {
|
|
AppendNullCheck(call, &array);
|
|
}
|
|
Definition* length = AppendLoadLength(call, array);
|
|
flow_graph_->ReplaceCurrentInstruction(current_iterator(), call, length);
|
|
RefineUseTypes(length);
|
|
}
|
|
|
|
void TypedDataSpecializer::ReplaceWithIndexGet(TemplateDartCall<0>* call,
|
|
classid_t cid) {
|
|
const intptr_t receiver_idx = call->FirstArgIndex();
|
|
auto array = call->ArgumentAt(receiver_idx + 0);
|
|
auto index = call->ArgumentAt(receiver_idx + 1);
|
|
|
|
if (array->Type()->is_nullable()) {
|
|
AppendNullCheck(call, &array);
|
|
}
|
|
if (index->Type()->is_nullable()) {
|
|
AppendNullCheck(call, &index);
|
|
}
|
|
AppendBoundsCheck(call, array, &index);
|
|
Definition* value = AppendLoadIndexed(call, array, index, cid);
|
|
flow_graph_->ReplaceCurrentInstruction(current_iterator(), call, value);
|
|
RefineUseTypes(value);
|
|
}
|
|
|
|
void TypedDataSpecializer::ReplaceWithIndexSet(TemplateDartCall<0>* call,
|
|
classid_t cid) {
|
|
const intptr_t receiver_idx = call->FirstArgIndex();
|
|
auto array = call->ArgumentAt(receiver_idx + 0);
|
|
auto index = call->ArgumentAt(receiver_idx + 1);
|
|
auto value = call->ArgumentAt(receiver_idx + 2);
|
|
|
|
if (array->Type()->is_nullable()) {
|
|
AppendNullCheck(call, &array);
|
|
}
|
|
if (index->Type()->is_nullable()) {
|
|
AppendNullCheck(call, &index);
|
|
}
|
|
if (value->Type()->is_nullable()) {
|
|
AppendNullCheck(call, &value);
|
|
}
|
|
AppendBoundsCheck(call, array, &index);
|
|
AppendStoreIndexed(call, array, index, value, cid);
|
|
|
|
RELEASE_ASSERT(!call->HasUses());
|
|
flow_graph_->ReplaceCurrentInstruction(current_iterator(), call, nullptr);
|
|
}
|
|
|
|
void TypedDataSpecializer::AppendNullCheck(TemplateDartCall<0>* call,
|
|
Definition** value) {
|
|
auto check =
|
|
new (Z) CheckNullInstr(new (Z) Value(*value), Symbols::OptimizedOut(),
|
|
call->deopt_id(), call->source());
|
|
flow_graph_->InsertBefore(call, check, call->env(), FlowGraph::kValue);
|
|
|
|
// Use data dependency as control dependency.
|
|
*value = check;
|
|
}
|
|
|
|
void TypedDataSpecializer::AppendBoundsCheck(TemplateDartCall<0>* call,
|
|
Definition* array,
|
|
Definition** index) {
|
|
auto length = new (Z) LoadFieldInstr(
|
|
new (Z) Value(array), Slot::TypedDataBase_length(), call->source());
|
|
flow_graph_->InsertBefore(call, length, call->env(), FlowGraph::kValue);
|
|
|
|
auto check = new (Z) GenericCheckBoundInstr(
|
|
new (Z) Value(length), new (Z) Value(*index), DeoptId::kNone);
|
|
flow_graph_->InsertBefore(call, check, call->env(), FlowGraph::kValue);
|
|
|
|
// Use data dependency as control dependency.
|
|
*index = check;
|
|
}
|
|
|
|
Definition* TypedDataSpecializer::AppendLoadLength(TemplateDartCall<0>* call,
|
|
Definition* array) {
|
|
auto length = new (Z) LoadFieldInstr(
|
|
new (Z) Value(array), Slot::TypedDataBase_length(), call->source());
|
|
flow_graph_->InsertBefore(call, length, call->env(), FlowGraph::kValue);
|
|
return length;
|
|
}
|
|
|
|
Definition* TypedDataSpecializer::AppendLoadIndexed(TemplateDartCall<0>* call,
|
|
Definition* array,
|
|
Definition* index,
|
|
classid_t cid) {
|
|
const intptr_t element_size = TypedDataBase::ElementSizeFor(cid);
|
|
const intptr_t index_scale = element_size;
|
|
|
|
auto data = new (Z) LoadUntaggedInstr(
|
|
new (Z) Value(array), compiler::target::PointerBase::data_offset());
|
|
flow_graph_->InsertBefore(call, data, call->env(), FlowGraph::kValue);
|
|
|
|
Definition* load = new (Z) LoadIndexedInstr(
|
|
new (Z) Value(data), new (Z) Value(index), /*index_unboxed=*/false,
|
|
index_scale, cid, kAlignedAccess, DeoptId::kNone, call->source());
|
|
flow_graph_->InsertBefore(call, load, call->env(), FlowGraph::kValue);
|
|
|
|
if (cid == kTypedDataFloat32ArrayCid) {
|
|
load = new (Z) FloatToDoubleInstr(new (Z) Value(load), call->deopt_id());
|
|
flow_graph_->InsertBefore(call, load, call->env(), FlowGraph::kValue);
|
|
}
|
|
|
|
return load;
|
|
}
|
|
|
|
void TypedDataSpecializer::AppendStoreIndexed(TemplateDartCall<0>* call,
|
|
Definition* array,
|
|
Definition* index,
|
|
Definition* value,
|
|
classid_t cid) {
|
|
const intptr_t element_size = TypedDataBase::ElementSizeFor(cid);
|
|
const intptr_t index_scale = element_size;
|
|
|
|
const auto deopt_id = call->deopt_id();
|
|
|
|
switch (cid) {
|
|
case kTypedDataInt8ArrayCid:
|
|
case kTypedDataUint8ArrayCid:
|
|
case kTypedDataUint8ClampedArrayCid:
|
|
case kTypedDataInt16ArrayCid:
|
|
case kTypedDataUint16ArrayCid:
|
|
case kExternalTypedDataUint8ArrayCid:
|
|
case kExternalTypedDataUint8ClampedArrayCid: {
|
|
// Insert explicit unboxing instructions with truncation to avoid relying
|
|
// on [SelectRepresentations] which doesn't mark them as truncating.
|
|
value = UnboxInstr::Create(kUnboxedIntPtr, new (Z) Value(value), deopt_id,
|
|
Instruction::kNotSpeculative);
|
|
flow_graph_->InsertBefore(call, value, call->env(), FlowGraph::kValue);
|
|
break;
|
|
}
|
|
case kTypedDataInt32ArrayCid: {
|
|
// Insert explicit unboxing instructions with truncation to avoid relying
|
|
// on [SelectRepresentations] which doesn't mark them as truncating.
|
|
value = UnboxInstr::Create(kUnboxedInt32, new (Z) Value(value), deopt_id,
|
|
Instruction::kNotSpeculative);
|
|
flow_graph_->InsertBefore(call, value, call->env(), FlowGraph::kValue);
|
|
break;
|
|
}
|
|
case kTypedDataUint32ArrayCid: {
|
|
// Insert explicit unboxing instructions with truncation to avoid relying
|
|
// on [SelectRepresentations] which doesn't mark them as truncating.
|
|
value = UnboxInstr::Create(kUnboxedUint32, new (Z) Value(value), deopt_id,
|
|
Instruction::kNotSpeculative);
|
|
flow_graph_->InsertBefore(call, value, call->env(), FlowGraph::kValue);
|
|
break;
|
|
}
|
|
case kTypedDataInt64ArrayCid:
|
|
case kTypedDataUint64ArrayCid: {
|
|
// Insert explicit unboxing instructions with truncation to avoid relying
|
|
// on [SelectRepresentations] which doesn't mark them as truncating.
|
|
value = UnboxInstr::Create(kUnboxedInt64, new (Z) Value(value),
|
|
DeoptId::kNone, Instruction::kNotSpeculative);
|
|
flow_graph_->InsertBefore(call, value, call->env(), FlowGraph::kValue);
|
|
break;
|
|
}
|
|
case kTypedDataFloat32ArrayCid: {
|
|
value = new (Z) DoubleToFloatInstr(new (Z) Value(value), deopt_id,
|
|
Instruction::kNotSpeculative);
|
|
flow_graph_->InsertBefore(call, value, call->env(), FlowGraph::kValue);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
auto data = new (Z) LoadUntaggedInstr(
|
|
new (Z) Value(array), compiler::target::PointerBase::data_offset());
|
|
flow_graph_->InsertBefore(call, data, call->env(), FlowGraph::kValue);
|
|
|
|
auto store = new (Z) StoreIndexedInstr(
|
|
new (Z) Value(data), new (Z) Value(index), new (Z) Value(value),
|
|
kNoStoreBarrier, /*index_unboxed=*/false, index_scale, cid,
|
|
kAlignedAccess, DeoptId::kNone, call->source(),
|
|
Instruction::kNotSpeculative);
|
|
flow_graph_->InsertBefore(call, store, call->env(), FlowGraph::kEffect);
|
|
}
|
|
|
|
void CallSpecializer::ReplaceInstanceCallsWithDispatchTableCalls() {
|
|
// Only implemented for AOT.
|
|
}
|
|
|
|
} // namespace dart
|