dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Files
a5ff656da170eddcdc87f84e9d4e324ce89d00d8
sdk/runtime/vm/compiler/graph_intrinsifier.cc
T
Ryan Macnak 55645786bc Revert "[vm, compiler] Support unboxed parameters for integer intrinsics." 
This reverts commit 1d369b5000.

Reason for revert: Failures on Golem

Original change's description:
> [vm, compiler] Support unboxed parameters for integer intrinsics.
>
> TEST=ci
> Change-Id: I7f29471043c049ef1acf7cd4bcb0890db6d33aa4
> Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/192728
> Commit-Queue: Ryan Macnak <rmacnak@google.com>
> Reviewed-by: Alexander Markov <alexmarkov@google.com>
> Reviewed-by: Martin Kustermann <kustermann@google.com>

# Not skipping CQ checks because original CL landed > 1 day ago.

Change-Id: I09e54cd894c0f73bf3af215729567503c156ec3e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/195165
Reviewed-by: Ryan Macnak <rmacnak@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Commit-Queue: Ryan Macnak <rmacnak@google.com>
2021-04-13 17:05:47 +00:00

1255 lines
49 KiB
C++
Raw Blame History

// Copyright (c) 2019, 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.
// Class for intrinsifying functions.
#include "vm/compiler/graph_intrinsifier.h"
#include "vm/compiler/backend/block_builder.h"
#include "vm/compiler/backend/flow_graph.h"
#include "vm/compiler/backend/flow_graph_compiler.h"
#include "vm/compiler/backend/il.h"
#include "vm/compiler/backend/il_printer.h"
#include "vm/compiler/backend/inliner.h"
#include "vm/compiler/backend/linearscan.h"
#include "vm/compiler/backend/range_analysis.h"
#include "vm/compiler/compiler_pass.h"
#include "vm/compiler/intrinsifier.h"
#include "vm/compiler/jit/compiler.h"
#include "vm/cpu.h"
#include "vm/flag_list.h"
namespace dart {
DECLARE_FLAG(bool, print_flow_graph);
DECLARE_FLAG(bool, print_flow_graph_optimized);
class GraphInstrinsicCodeGenScope {
public:
explicit GraphInstrinsicCodeGenScope(FlowGraphCompiler* compiler)
: compiler_(compiler), old_is_optimizing_(compiler->is_optimizing()) {
compiler_->is_optimizing_ = true;
}
~GraphInstrinsicCodeGenScope() {
compiler_->is_optimizing_ = old_is_optimizing_;
}
private:
FlowGraphCompiler* compiler_;
bool old_is_optimizing_;
};
namespace compiler {
static void EmitCodeFor(FlowGraphCompiler* compiler, FlowGraph* graph) {
// For graph intrinsics we run the linearscan register allocator, which will
// pass opt=true for MakeLocationSummary. We therefore also have to ensure
// `compiler->is_optimizing()` is set to true during EmitNativeCode.
GraphInstrinsicCodeGenScope optimizing_scope(compiler);
compiler->assembler()->Comment("Graph intrinsic begin");
for (intptr_t i = 0; i < graph->reverse_postorder().length(); i++) {
BlockEntryInstr* block = graph->reverse_postorder()[i];
if (block->IsGraphEntry()) continue; // No code for graph entry needed.
if (block->HasParallelMove()) {
compiler->parallel_move_resolver()->EmitNativeCode(
block->parallel_move());
}
for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
Instruction* instr = it.Current();
if (FLAG_code_comments) compiler->EmitComment(instr);
if (instr->IsParallelMove()) {
compiler->parallel_move_resolver()->EmitNativeCode(
instr->AsParallelMove());
} else if (instr->IsInvokeMathCFunction()) {
ASSERT(instr->locs() != NULL);
GraphIntrinsifier::IntrinsicCallPrologue(compiler->assembler());
instr->EmitNativeCode(compiler);
GraphIntrinsifier::IntrinsicCallEpilogue(compiler->assembler());
} else {
ASSERT(instr->locs() != NULL);
// Calls are not supported in intrinsics code.
ASSERT(!instr->locs()->always_calls());
instr->EmitNativeCode(compiler);
}
}
}
compiler->assembler()->Comment("Graph intrinsic end");
}
bool GraphIntrinsifier::GraphIntrinsify(const ParsedFunction& parsed_function,
FlowGraphCompiler* compiler) {
ASSERT(!parsed_function.function().HasOptionalParameters());
PrologueInfo prologue_info(-1, -1);
auto graph_entry =
new GraphEntryInstr(parsed_function, Compiler::kNoOSRDeoptId);
intptr_t block_id = 1; // 0 is GraphEntry.
graph_entry->set_normal_entry(
new FunctionEntryInstr(graph_entry, block_id, kInvalidTryIndex,
CompilerState::Current().GetNextDeoptId()));
FlowGraph* graph =
new FlowGraph(parsed_function, graph_entry, block_id, prologue_info);
compiler->set_intrinsic_flow_graph(*graph);
const Function& function = parsed_function.function();
switch (function.recognized_kind()) {
#define EMIT_CASE(class_name, function_name, enum_name, fp) \
case MethodRecognizer::k##enum_name: \
if (!Build_##enum_name(graph)) return false; \
break;
GRAPH_INTRINSICS_LIST(EMIT_CASE);
#undef EMIT_CASE
default:
if (function.IsImplicitGetterFunction()) {
if (!Build_ImplicitGetter(graph)) return false;
} else if (function.IsImplicitSetterFunction()) {
if (!Build_ImplicitSetter(graph)) return false;
} else {
return false;
}
}
if (FLAG_support_il_printer && FLAG_print_flow_graph &&
FlowGraphPrinter::ShouldPrint(function)) {
THR_Print("Intrinsic graph before\n");
FlowGraphPrinter printer(*graph);
printer.PrintBlocks();
}
// Prepare for register allocation (cf. FinalizeGraph).
graph->RemoveRedefinitions();
// Ensure dominators are re-computed. Normally this is done during SSA
// construction (which we don't do for graph intrinsics).
GrowableArray<BitVector*> dominance_frontier;
graph->ComputeDominators(&dominance_frontier);
CompilerPassState state(parsed_function.thread(), graph,
/*speculative_inlining_policy*/ nullptr);
CompilerPass::RunGraphIntrinsicPipeline(&state);
if (FLAG_support_il_printer && FLAG_print_flow_graph &&
FlowGraphPrinter::ShouldPrint(function)) {
THR_Print("Intrinsic graph after\n");
FlowGraphPrinter printer(*graph);
printer.PrintBlocks();
}
EmitCodeFor(compiler, graph);
return true;
}
static Representation RepresentationForCid(intptr_t cid) {
switch (cid) {
case kDoubleCid:
return kUnboxedDouble;
case kFloat32x4Cid:
return kUnboxedFloat32x4;
case kInt32x4Cid:
return kUnboxedInt32x4;
case kFloat64x2Cid:
return kUnboxedFloat64x2;
default:
UNREACHABLE();
return kNoRepresentation;
}
}
// Notes about the graph intrinsics:
//
// IR instructions which would jump to a deoptimization sequence on failure
// instead branch to the intrinsic slow path.
//
static Definition* PrepareIndexedOp(FlowGraph* flow_graph,
BlockBuilder* builder,
Definition* array,
Definition* index,
const Slot& length_field) {
Definition* length = builder->AddDefinition(
new LoadFieldInstr(new Value(array), length_field, InstructionSource()));
// Note that the intrinsifier must always use deopting array bound
// checks, because intrinsics currently don't support calls.
Definition* safe_index = new CheckArrayBoundInstr(
new Value(length), new Value(index), DeoptId::kNone);
builder->AddDefinition(safe_index);
return safe_index;
}
static void VerifyParameterIsBoxed(BlockBuilder* builder, intptr_t arg_index) {
const auto& function = builder->function();
if (function.is_unboxed_parameter_at(arg_index)) {
FATAL2("Unsupported unboxed parameter %" Pd " in %s", arg_index,
function.ToFullyQualifiedCString());
}
}
static Definition* CreateBoxedParameterIfNeeded(BlockBuilder* builder,
Definition* value,
Representation representation,
intptr_t arg_index) {
const auto& function = builder->function();
if (function.is_unboxed_parameter_at(arg_index)) {
return builder->AddDefinition(
BoxInstr::Create(representation, new Value(value)));
} else {
return value;
}
}
static Definition* CreateBoxedResultIfNeeded(BlockBuilder* builder,
Definition* value,
Representation representation) {
const auto& function = builder->function();
if (function.has_unboxed_return()) {
return value;
} else {
return builder->AddDefinition(
BoxInstr::Create(representation, new Value(value)));
}
}
static Definition* CreateUnboxedResultIfNeeded(BlockBuilder* builder,
Definition* value) {
const auto& function = builder->function();
if (function.has_unboxed_return() && value->representation() == kTagged) {
return builder->AddUnboxInstr(FlowGraph::ReturnRepresentationOf(function),
new Value(value), /* is_checked = */ true);
} else {
return value;
}
}
static bool IntrinsifyArrayGetIndexed(FlowGraph* flow_graph,
intptr_t array_cid) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* array = builder.AddParameter(0, /*with_frame=*/false);
Definition* index = builder.AddParameter(1, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
index = CreateBoxedParameterIfNeeded(&builder, index, kUnboxedInt64, 1);
index = PrepareIndexedOp(flow_graph, &builder, array, index,
Slot::GetLengthFieldForArrayCid(array_cid));
if (IsExternalTypedDataClassId(array_cid)) {
array = builder.AddDefinition(new LoadUntaggedInstr(
new Value(array), target::TypedDataBase::data_field_offset()));
}
Definition* result = builder.AddDefinition(new LoadIndexedInstr(
new Value(array), new Value(index), /*index_unboxed=*/false,
/*index_scale=*/target::Instance::ElementSizeFor(array_cid), array_cid,
kAlignedAccess, DeoptId::kNone, builder.Source()));
// We don't perform [RangeAnalysis] for graph intrinsics. To inform the
// following boxing instruction about a more precise range we attach it here
// manually.
// http://dartbug.com/36632
const bool known_range =
array_cid == kTypedDataInt8ArrayCid ||
array_cid == kTypedDataUint8ArrayCid ||
array_cid == kTypedDataUint8ClampedArrayCid ||
array_cid == kExternalTypedDataUint8ArrayCid ||
array_cid == kExternalTypedDataUint8ClampedArrayCid ||
array_cid == kTypedDataInt16ArrayCid ||
array_cid == kTypedDataUint16ArrayCid ||
array_cid == kTypedDataInt32ArrayCid ||
array_cid == kTypedDataUint32ArrayCid || array_cid == kOneByteStringCid ||
array_cid == kTwoByteStringCid;
bool clear_environment = false;
if (known_range) {
Range range;
result->InferRange(/*range_analysis=*/nullptr, &range);
result->set_range(range);
clear_environment = range.Fits(RangeBoundary::kRangeBoundarySmi);
}
// Box and/or convert result if necessary.
switch (array_cid) {
case kTypedDataInt32ArrayCid:
case kExternalTypedDataInt32ArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedInt32);
break;
case kTypedDataUint32ArrayCid:
case kExternalTypedDataUint32ArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedUint32);
break;
case kTypedDataFloat32ArrayCid:
result = builder.AddDefinition(
new FloatToDoubleInstr(new Value(result), DeoptId::kNone));
FALL_THROUGH;
case kTypedDataFloat64ArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedDouble);
break;
case kTypedDataFloat32x4ArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedFloat32x4);
break;
case kTypedDataInt32x4ArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedInt32x4);
break;
case kTypedDataFloat64x2ArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedFloat64x2);
break;
case kArrayCid:
case kImmutableArrayCid:
// Nothing to do.
break;
case kTypedDataInt8ArrayCid:
case kTypedDataInt16ArrayCid:
case kTypedDataUint8ArrayCid:
case kTypedDataUint8ClampedArrayCid:
case kTypedDataUint16ArrayCid:
case kExternalTypedDataUint8ArrayCid:
case kExternalTypedDataUint8ClampedArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedIntPtr);
break;
case kTypedDataInt64ArrayCid:
case kTypedDataUint64ArrayCid:
result = CreateBoxedResultIfNeeded(&builder, result, kUnboxedInt64);
break;
default:
UNREACHABLE();
break;
}
if (result->IsBoxInteger() && clear_environment) {
result->AsBoxInteger()->ClearEnv();
}
result = CreateUnboxedResultIfNeeded(&builder, result);
builder.AddReturn(new Value(result));
return true;
}
static bool IntrinsifyArraySetIndexed(FlowGraph* flow_graph,
intptr_t array_cid) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* array = builder.AddParameter(0, /*with_frame=*/false);
Definition* index = builder.AddParameter(1, /*with_frame=*/false);
Definition* value = builder.AddParameter(2, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
VerifyParameterIsBoxed(&builder, 2);
index = CreateBoxedParameterIfNeeded(&builder, index, kUnboxedInt64, 1);
index = PrepareIndexedOp(flow_graph, &builder, array, index,
Slot::GetLengthFieldForArrayCid(array_cid));
// Value check/conversion.
switch (array_cid) {
case kTypedDataUint8ClampedArrayCid:
case kExternalTypedDataUint8ClampedArrayCid:
#if defined(TARGET_ARCH_IS_32_BIT)
// On 32-bit architectures, clamping operations need the exact value
// for proper operations. On 64-bit architectures, kUnboxedIntPtr
// maps to kUnboxedInt64. All other situations get away with
// truncating even non-smi values.
builder.AddInstruction(new CheckSmiInstr(new Value(value), DeoptId::kNone,
builder.Source()));
FALL_THROUGH;
#endif
case kTypedDataInt8ArrayCid:
case kTypedDataInt16ArrayCid:
case kTypedDataUint8ArrayCid:
case kTypedDataUint16ArrayCid:
case kExternalTypedDataUint8ArrayCid:
value = builder.AddUnboxInstr(kUnboxedIntPtr, new Value(value),
/* is_checked = */ false);
value->AsUnboxInteger()->mark_truncating();
break;
case kTypedDataInt32ArrayCid:
case kExternalTypedDataInt32ArrayCid:
// Use same truncating unbox-instruction for int32 and uint32.
FALL_THROUGH;
case kTypedDataUint32ArrayCid:
case kExternalTypedDataUint32ArrayCid:
// Supports smi and mint, slow-case for bigints.
value = builder.AddUnboxInstr(kUnboxedUint32, new Value(value),
/* is_checked = */ false);
break;
case kTypedDataInt64ArrayCid:
case kTypedDataUint64ArrayCid:
value = builder.AddUnboxInstr(kUnboxedInt64, new Value(value),
/* is_checked = */ false);
break;
case kTypedDataFloat32ArrayCid:
case kTypedDataFloat64ArrayCid:
case kTypedDataFloat32x4ArrayCid:
case kTypedDataInt32x4ArrayCid:
case kTypedDataFloat64x2ArrayCid: {
intptr_t value_check_cid = kDoubleCid;
Representation rep = kUnboxedDouble;
switch (array_cid) {
case kTypedDataFloat32x4ArrayCid:
value_check_cid = kFloat32x4Cid;
rep = kUnboxedFloat32x4;
break;
case kTypedDataInt32x4ArrayCid:
value_check_cid = kInt32x4Cid;
rep = kUnboxedInt32x4;
break;
case kTypedDataFloat64x2ArrayCid:
value_check_cid = kFloat64x2Cid;
rep = kUnboxedFloat64x2;
break;
default:
// Float32/Float64 case already handled.
break;
}
Zone* zone = flow_graph->zone();
Cids* value_check = Cids::CreateMonomorphic(zone, value_check_cid);
builder.AddInstruction(new CheckClassInstr(
new Value(value), DeoptId::kNone, *value_check, builder.Source()));
value = builder.AddUnboxInstr(rep, new Value(value),
/* is_checked = */ true);
if (array_cid == kTypedDataFloat32ArrayCid) {
value = builder.AddDefinition(
new DoubleToFloatInstr(new Value(value), DeoptId::kNone));
}
break;
}
default:
UNREACHABLE();
}
if (IsExternalTypedDataClassId(array_cid)) {
array = builder.AddDefinition(new LoadUntaggedInstr(
new Value(array), target::TypedDataBase::data_field_offset()));
}
// No store barrier.
ASSERT(IsExternalTypedDataClassId(array_cid) ||
IsTypedDataClassId(array_cid));
builder.AddInstruction(new StoreIndexedInstr(
new Value(array), new Value(index), new Value(value), kNoStoreBarrier,
/*index_unboxed=*/false,
/*index_scale=*/target::Instance::ElementSizeFor(array_cid), array_cid,
kAlignedAccess, DeoptId::kNone, builder.Source()));
// Return null.
Definition* null_def = builder.AddNullDefinition();
builder.AddReturn(new Value(null_def));
return true;
}
#define DEFINE_ARRAY_GETTER_INTRINSIC(enum_name) \
bool GraphIntrinsifier::Build_##enum_name##GetIndexed( \
FlowGraph* flow_graph) { \
return IntrinsifyArrayGetIndexed( \
flow_graph, MethodRecognizer::MethodKindToReceiverCid( \
MethodRecognizer::k##enum_name##GetIndexed)); \
}
#define DEFINE_ARRAY_SETTER_INTRINSIC(enum_name) \
bool GraphIntrinsifier::Build_##enum_name##SetIndexed( \
FlowGraph* flow_graph) { \
return IntrinsifyArraySetIndexed( \
flow_graph, MethodRecognizer::MethodKindToReceiverCid( \
MethodRecognizer::k##enum_name##SetIndexed)); \
}
DEFINE_ARRAY_GETTER_INTRINSIC(ObjectArray)
DEFINE_ARRAY_GETTER_INTRINSIC(ImmutableArray)
#define DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(enum_name) \
DEFINE_ARRAY_GETTER_INTRINSIC(enum_name) \
DEFINE_ARRAY_SETTER_INTRINSIC(enum_name)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Int8Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Uint8Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(ExternalUint8Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Uint8ClampedArray)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(ExternalUint8ClampedArray)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Int16Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Uint16Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Int32Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Uint32Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Int64Array)
DEFINE_ARRAY_GETTER_SETTER_INTRINSICS(Uint64Array)
#undef DEFINE_ARRAY_GETTER_SETTER_INTRINSICS
#undef DEFINE_ARRAY_GETTER_INTRINSIC
#undef DEFINE_ARRAY_SETTER_INTRINSIC
#define DEFINE_FLOAT_ARRAY_GETTER_INTRINSIC(enum_name) \
bool GraphIntrinsifier::Build_##enum_name##GetIndexed( \
FlowGraph* flow_graph) { \
if (!FlowGraphCompiler::SupportsUnboxedDoubles()) { \
return false; \
} \
return IntrinsifyArrayGetIndexed( \
flow_graph, MethodRecognizer::MethodKindToReceiverCid( \
MethodRecognizer::k##enum_name##GetIndexed)); \
}
#define DEFINE_FLOAT_ARRAY_SETTER_INTRINSIC(enum_name) \
bool GraphIntrinsifier::Build_##enum_name##SetIndexed( \
FlowGraph* flow_graph) { \
if (!FlowGraphCompiler::SupportsUnboxedDoubles()) { \
return false; \
} \
return IntrinsifyArraySetIndexed( \
flow_graph, MethodRecognizer::MethodKindToReceiverCid( \
MethodRecognizer::k##enum_name##SetIndexed)); \
}
#define DEFINE_FLOAT_ARRAY_GETTER_SETTER_INTRINSICS(enum_name) \
DEFINE_FLOAT_ARRAY_GETTER_INTRINSIC(enum_name) \
DEFINE_FLOAT_ARRAY_SETTER_INTRINSIC(enum_name)
DEFINE_FLOAT_ARRAY_GETTER_SETTER_INTRINSICS(Float64Array)
DEFINE_FLOAT_ARRAY_GETTER_SETTER_INTRINSICS(Float32Array)
#undef DEFINE_FLOAT_ARRAY_GETTER_SETTER_INTRINSICS
#undef DEFINE_FLOAT_ARRAY_GETTER_INTRINSIC
#undef DEFINE_FLOAT_ARRAY_SETTER_INTRINSIC
#define DEFINE_SIMD_ARRAY_GETTER_INTRINSIC(enum_name) \
bool GraphIntrinsifier::Build_##enum_name##GetIndexed( \
FlowGraph* flow_graph) { \
if (!FlowGraphCompiler::SupportsUnboxedSimd128()) { \
return false; \
} \
return IntrinsifyArrayGetIndexed( \
flow_graph, MethodRecognizer::MethodKindToReceiverCid( \
MethodRecognizer::k##enum_name##GetIndexed)); \
}
#define DEFINE_SIMD_ARRAY_SETTER_INTRINSIC(enum_name) \
bool GraphIntrinsifier::Build_##enum_name##SetIndexed( \
FlowGraph* flow_graph) { \
if (!FlowGraphCompiler::SupportsUnboxedSimd128()) { \
return false; \
} \
return IntrinsifyArraySetIndexed( \
flow_graph, MethodRecognizer::MethodKindToReceiverCid( \
MethodRecognizer::k##enum_name##SetIndexed)); \
}
#define DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(enum_name) \
DEFINE_SIMD_ARRAY_GETTER_INTRINSIC(enum_name) \
DEFINE_SIMD_ARRAY_SETTER_INTRINSIC(enum_name)
DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(Float32x4Array)
DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(Int32x4Array)
DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS(Float64x2Array)
#undef DEFINE_SIMD_ARRAY_GETTER_SETTER_INTRINSICS
#undef DEFINE_SIMD_ARRAY_GETTER_INTRINSIC
#undef DEFINE_SIMD_ARRAY_SETTER_INTRINSIC
static bool BuildCodeUnitAt(FlowGraph* flow_graph, intptr_t cid) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* str = builder.AddParameter(0, /*with_frame=*/false);
Definition* index = builder.AddParameter(1, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
index = CreateBoxedParameterIfNeeded(&builder, index, kUnboxedInt64, 1);
index =
PrepareIndexedOp(flow_graph, &builder, str, index, Slot::String_length());
// For external strings: Load external data.
if (cid == kExternalOneByteStringCid) {
str = builder.AddDefinition(new LoadUntaggedInstr(
new Value(str), target::ExternalOneByteString::external_data_offset()));
} else if (cid == kExternalTwoByteStringCid) {
str = builder.AddDefinition(new LoadUntaggedInstr(
new Value(str), target::ExternalTwoByteString::external_data_offset()));
}
Definition* load = builder.AddDefinition(new LoadIndexedInstr(
new Value(str), new Value(index), /*index_unboxed=*/false,
target::Instance::ElementSizeFor(cid), cid, kAlignedAccess,
DeoptId::kNone, builder.Source()));
// We don't perform [RangeAnalysis] for graph intrinsics. To inform the
// following boxing instruction about a more precise range we attach it here
// manually.
// http://dartbug.com/36632
Range range;
load->InferRange(/*range_analysis=*/nullptr, &range);
load->set_range(range);
Definition* result =
CreateBoxedResultIfNeeded(&builder, load, kUnboxedIntPtr);
if (result->IsBoxInteger()) {
result->AsBoxInteger()->ClearEnv();
}
builder.AddReturn(new Value(result));
return true;
}
bool GraphIntrinsifier::Build_OneByteStringCodeUnitAt(FlowGraph* flow_graph) {
return BuildCodeUnitAt(flow_graph, kOneByteStringCid);
}
bool GraphIntrinsifier::Build_TwoByteStringCodeUnitAt(FlowGraph* flow_graph) {
return BuildCodeUnitAt(flow_graph, kTwoByteStringCid);
}
bool GraphIntrinsifier::Build_ExternalOneByteStringCodeUnitAt(
FlowGraph* flow_graph) {
return BuildCodeUnitAt(flow_graph, kExternalOneByteStringCid);
}
bool GraphIntrinsifier::Build_ExternalTwoByteStringCodeUnitAt(
FlowGraph* flow_graph) {
return BuildCodeUnitAt(flow_graph, kExternalTwoByteStringCid);
}
static bool BuildSimdOp(FlowGraph* flow_graph, intptr_t cid, Token::Kind kind) {
if (!FlowGraphCompiler::SupportsUnboxedSimd128()) return false;
const Representation rep = RepresentationForCid(cid);
Zone* zone = flow_graph->zone();
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* left = builder.AddParameter(0, /*with_frame=*/false);
Definition* right = builder.AddParameter(1, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
VerifyParameterIsBoxed(&builder, 1);
Cids* value_check = Cids::CreateMonomorphic(zone, cid);
// Check argument. Receiver (left) is known to be a Float32x4.
builder.AddInstruction(new CheckClassInstr(new Value(right), DeoptId::kNone,
*value_check, builder.Source()));
Definition* left_simd = builder.AddUnboxInstr(rep, new Value(left),
/* is_checked = */ true);
Definition* right_simd = builder.AddUnboxInstr(rep, new Value(right),
/* is_checked = */ true);
Definition* unboxed_result = builder.AddDefinition(SimdOpInstr::Create(
SimdOpInstr::KindForOperator(cid, kind), new Value(left_simd),
new Value(right_simd), DeoptId::kNone));
Definition* result = CreateBoxedResultIfNeeded(&builder, unboxed_result, rep);
builder.AddReturn(new Value(result));
return true;
}
bool GraphIntrinsifier::Build_Float32x4Mul(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat32x4Cid, Token::kMUL);
}
bool GraphIntrinsifier::Build_Float32x4Div(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat32x4Cid, Token::kDIV);
}
bool GraphIntrinsifier::Build_Float32x4Sub(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat32x4Cid, Token::kSUB);
}
bool GraphIntrinsifier::Build_Float32x4Add(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat32x4Cid, Token::kADD);
}
bool GraphIntrinsifier::Build_Float64x2Mul(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat64x2Cid, Token::kMUL);
}
bool GraphIntrinsifier::Build_Float64x2Div(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat64x2Cid, Token::kDIV);
}
bool GraphIntrinsifier::Build_Float64x2Sub(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat64x2Cid, Token::kSUB);
}
bool GraphIntrinsifier::Build_Float64x2Add(FlowGraph* flow_graph) {
return BuildSimdOp(flow_graph, kFloat64x2Cid, Token::kADD);
}
static bool BuildFloat32x4Shuffle(FlowGraph* flow_graph,
MethodRecognizer::Kind kind) {
if (!FlowGraphCompiler::SupportsUnboxedDoubles() ||
!FlowGraphCompiler::SupportsUnboxedSimd128()) {
return false;
}
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* receiver = builder.AddParameter(0, /*with_frame=*/false);
const auto& function = flow_graph->function();
Definition* unboxed_receiver =
!function.is_unboxed_parameter_at(0)
? builder.AddUnboxInstr(kUnboxedFloat32x4, new Value(receiver),
/* is_checked = */ true)
: receiver;
Definition* unboxed_result = builder.AddDefinition(
SimdOpInstr::Create(kind, new Value(unboxed_receiver), DeoptId::kNone));
Definition* result =
CreateBoxedResultIfNeeded(&builder, unboxed_result, kUnboxedDouble);
builder.AddReturn(new Value(result));
return true;
}
bool GraphIntrinsifier::Build_Float32x4ShuffleX(FlowGraph* flow_graph) {
return BuildFloat32x4Shuffle(flow_graph,
MethodRecognizer::kFloat32x4ShuffleX);
}
bool GraphIntrinsifier::Build_Float32x4ShuffleY(FlowGraph* flow_graph) {
return BuildFloat32x4Shuffle(flow_graph,
MethodRecognizer::kFloat32x4ShuffleY);
}
bool GraphIntrinsifier::Build_Float32x4ShuffleZ(FlowGraph* flow_graph) {
return BuildFloat32x4Shuffle(flow_graph,
MethodRecognizer::kFloat32x4ShuffleZ);
}
bool GraphIntrinsifier::Build_Float32x4ShuffleW(FlowGraph* flow_graph) {
return BuildFloat32x4Shuffle(flow_graph,
MethodRecognizer::kFloat32x4ShuffleW);
}
static bool BuildLoadField(FlowGraph* flow_graph, const Slot& field) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* array = builder.AddParameter(0, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
Definition* length = builder.AddDefinition(
new LoadFieldInstr(new Value(array), field, builder.Source()));
length = CreateUnboxedResultIfNeeded(&builder, length);
builder.AddReturn(new Value(length));
return true;
}
bool GraphIntrinsifier::Build_ObjectArrayLength(FlowGraph* flow_graph) {
return BuildLoadField(flow_graph, Slot::Array_length());
}
bool GraphIntrinsifier::Build_ImmutableArrayLength(FlowGraph* flow_graph) {
return BuildLoadField(flow_graph, Slot::Array_length());
}
bool GraphIntrinsifier::Build_GrowableArrayLength(FlowGraph* flow_graph) {
return BuildLoadField(flow_graph, Slot::GrowableObjectArray_length());
}
bool GraphIntrinsifier::Build_StringBaseLength(FlowGraph* flow_graph) {
return BuildLoadField(flow_graph, Slot::String_length());
}
bool GraphIntrinsifier::Build_TypedListLength(FlowGraph* flow_graph) {
return BuildLoadField(flow_graph, Slot::TypedDataBase_length());
}
bool GraphIntrinsifier::Build_TypedListViewLength(FlowGraph* flow_graph) {
return BuildLoadField(flow_graph, Slot::TypedDataBase_length());
}
bool GraphIntrinsifier::Build_ByteDataViewLength(FlowGraph* flow_graph) {
return BuildLoadField(flow_graph, Slot::TypedDataBase_length());
}
bool GraphIntrinsifier::Build_GrowableArrayCapacity(FlowGraph* flow_graph) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* array = builder.AddParameter(0, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
Definition* backing_store = builder.AddDefinition(new LoadFieldInstr(
new Value(array), Slot::GrowableObjectArray_data(), builder.Source()));
Definition* capacity = builder.AddDefinition(new LoadFieldInstr(
new Value(backing_store), Slot::Array_length(), builder.Source()));
capacity = CreateUnboxedResultIfNeeded(&builder, capacity);
builder.AddReturn(new Value(capacity));
return true;
}
bool GraphIntrinsifier::Build_GrowableArrayGetIndexed(FlowGraph* flow_graph) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* growable_array = builder.AddParameter(0, /*with_frame=*/false);
Definition* index = builder.AddParameter(1, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
index = CreateBoxedParameterIfNeeded(&builder, index, kUnboxedInt64, 1);
index = PrepareIndexedOp(flow_graph, &builder, growable_array, index,
Slot::GrowableObjectArray_length());
Definition* backing_store = builder.AddDefinition(
new LoadFieldInstr(new Value(growable_array),
Slot::GrowableObjectArray_data(), builder.Source()));
Definition* result = builder.AddDefinition(new LoadIndexedInstr(
new Value(backing_store), new Value(index), /*index_unboxed=*/false,
/*index_scale=*/target::Instance::ElementSizeFor(kArrayCid), kArrayCid,
kAlignedAccess, DeoptId::kNone, builder.Source()));
result = CreateUnboxedResultIfNeeded(&builder, result);
builder.AddReturn(new Value(result));
return true;
}
bool GraphIntrinsifier::Build_ObjectArraySetIndexedUnchecked(
FlowGraph* flow_graph) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* array = builder.AddParameter(0, /*with_frame=*/false);
Definition* index = builder.AddParameter(1, /*with_frame=*/false);
Definition* value = builder.AddParameter(2, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
VerifyParameterIsBoxed(&builder, 2);
index = CreateBoxedParameterIfNeeded(&builder, index, kUnboxedInt64, 1);
index = PrepareIndexedOp(flow_graph, &builder, array, index,
Slot::Array_length());
builder.AddInstruction(new StoreIndexedInstr(
new Value(array), new Value(index), new Value(value), kEmitStoreBarrier,
/*index_unboxed=*/false,
/*index_scale=*/target::Instance::ElementSizeFor(kArrayCid), kArrayCid,
kAlignedAccess, DeoptId::kNone, builder.Source()));
// Return null.
Definition* null_def = builder.AddNullDefinition();
builder.AddReturn(new Value(null_def));
return true;
}
bool GraphIntrinsifier::Build_GrowableArraySetIndexedUnchecked(
FlowGraph* flow_graph) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* array = builder.AddParameter(0, /*with_frame=*/false);
Definition* index = builder.AddParameter(1, /*with_frame=*/false);
Definition* value = builder.AddParameter(2, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
VerifyParameterIsBoxed(&builder, 2);
index = CreateBoxedParameterIfNeeded(&builder, index, kUnboxedInt64, 1);
index = PrepareIndexedOp(flow_graph, &builder, array, index,
Slot::GrowableObjectArray_length());
Definition* backing_store = builder.AddDefinition(new LoadFieldInstr(
new Value(array), Slot::GrowableObjectArray_data(), builder.Source()));
builder.AddInstruction(new StoreIndexedInstr(
new Value(backing_store), new Value(index), new Value(value),
kEmitStoreBarrier, /*index_unboxed=*/false,
/*index_scale=*/target::Instance::ElementSizeFor(kArrayCid), kArrayCid,
kAlignedAccess, DeoptId::kNone, builder.Source()));
// Return null.
Definition* null_def = builder.AddNullDefinition();
builder.AddReturn(new Value(null_def));
return true;
}
bool GraphIntrinsifier::Build_GrowableArraySetData(FlowGraph* flow_graph) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* growable_array = builder.AddParameter(0, /*with_frame=*/false);
Definition* data = builder.AddParameter(1, /*with_frame=*/false);
Zone* zone = flow_graph->zone();
VerifyParameterIsBoxed(&builder, 0);
VerifyParameterIsBoxed(&builder, 1);
Cids* value_check = Cids::CreateMonomorphic(zone, kArrayCid);
builder.AddInstruction(new CheckClassInstr(new Value(data), DeoptId::kNone,
*value_check, builder.Source()));
builder.AddInstruction(new StoreInstanceFieldInstr(
Slot::GrowableObjectArray_data(), new Value(growable_array),
new Value(data), kEmitStoreBarrier, builder.Source()));
// Return null.
Definition* null_def = builder.AddNullDefinition();
builder.AddReturn(new Value(null_def));
return true;
}
bool GraphIntrinsifier::Build_GrowableArraySetLength(FlowGraph* flow_graph) {
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* growable_array = builder.AddParameter(0, /*with_frame=*/false);
Definition* length = builder.AddParameter(1, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
VerifyParameterIsBoxed(&builder, 1);
builder.AddInstruction(
new CheckSmiInstr(new Value(length), DeoptId::kNone, builder.Source()));
builder.AddInstruction(new StoreInstanceFieldInstr(
Slot::GrowableObjectArray_length(), new Value(growable_array),
new Value(length), kNoStoreBarrier, builder.Source()));
Definition* null_def = builder.AddNullDefinition();
builder.AddReturn(new Value(null_def));
return true;
}
static bool BuildUnarySmiOp(FlowGraph* flow_graph, Token::Kind op_kind) {
ASSERT(!flow_graph->function().has_unboxed_return());
ASSERT(!flow_graph->function().is_unboxed_parameter_at(0));
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* left = builder.AddParameter(0, /*with_frame=*/false);
builder.AddInstruction(
new CheckSmiInstr(new Value(left), DeoptId::kNone, builder.Source()));
Definition* result = builder.AddDefinition(
new UnarySmiOpInstr(op_kind, new Value(left), DeoptId::kNone));
builder.AddReturn(new Value(result));
return true;
}
bool GraphIntrinsifier::Build_Smi_bitNegate(FlowGraph* flow_graph) {
return BuildUnarySmiOp(flow_graph, Token::kBIT_NOT);
}
bool GraphIntrinsifier::Build_Integer_negate(FlowGraph* flow_graph) {
return BuildUnarySmiOp(flow_graph, Token::kNEGATE);
}
static bool BuildBinarySmiOp(FlowGraph* flow_graph, Token::Kind op_kind) {
ASSERT(!flow_graph->function().has_unboxed_return());
ASSERT(!flow_graph->function().is_unboxed_parameter_at(0));
ASSERT(!flow_graph->function().is_unboxed_parameter_at(1));
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* left = builder.AddParameter(0, /*with_frame=*/false);
Definition* right = builder.AddParameter(1, /*with_frame=*/false);
builder.AddInstruction(
new CheckSmiInstr(new Value(left), DeoptId::kNone, builder.Source()));
builder.AddInstruction(
new CheckSmiInstr(new Value(right), DeoptId::kNone, builder.Source()));
Definition* result = builder.AddDefinition(new BinarySmiOpInstr(
op_kind, new Value(left), new Value(right), DeoptId::kNone));
builder.AddReturn(new Value(result));
return true;
}
bool GraphIntrinsifier::Build_Integer_add(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kADD);
}
bool GraphIntrinsifier::Build_Integer_sub(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kSUB);
}
bool GraphIntrinsifier::Build_Integer_mul(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kMUL);
}
bool GraphIntrinsifier::Build_Integer_mod(FlowGraph* flow_graph) {
#if defined(TARGET_ARCH_ARM)
if (!TargetCPUFeatures::can_divide()) {
return false;
}
#endif
return BuildBinarySmiOp(flow_graph, Token::kMOD);
}
bool GraphIntrinsifier::Build_Integer_truncDivide(FlowGraph* flow_graph) {
#if defined(TARGET_ARCH_ARM)
if (!TargetCPUFeatures::can_divide()) {
return false;
}
#endif
return BuildBinarySmiOp(flow_graph, Token::kTRUNCDIV);
}
bool GraphIntrinsifier::Build_Integer_bitAnd(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kBIT_AND);
}
bool GraphIntrinsifier::Build_Integer_bitOr(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kBIT_OR);
}
bool GraphIntrinsifier::Build_Integer_bitXor(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kBIT_XOR);
}
bool GraphIntrinsifier::Build_Integer_sar(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kSHR);
}
bool GraphIntrinsifier::Build_Integer_shr(FlowGraph* flow_graph) {
return BuildBinarySmiOp(flow_graph, Token::kUSHR);
}
static Definition* ConvertOrUnboxDoubleParameter(BlockBuilder* builder,
Definition* value,
intptr_t index,
bool is_checked) {
const auto& function = builder->function();
if (function.is_unboxed_double_parameter_at(index)) {
return value;
} else if (function.is_unboxed_integer_parameter_at(index)) {
if (compiler::target::kWordSize == 4) {
// Int64ToDoubleInstr is not implemented in 32-bit platforms
return nullptr;
}
auto to_double = new Int64ToDoubleInstr(new Value(value), DeoptId::kNone);
return builder->AddDefinition(to_double);
} else {
ASSERT(!function.is_unboxed_parameter_at(index));
return builder->AddUnboxInstr(kUnboxedDouble, value, is_checked);
}
}
bool GraphIntrinsifier::Build_DoubleFlipSignBit(FlowGraph* flow_graph) {
if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
return false;
}
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
Definition* receiver = builder.AddParameter(0, /*with_frame=*/false);
Definition* unboxed_value = ConvertOrUnboxDoubleParameter(
&builder, receiver, 0, /* is_checked = */ true);
if (unboxed_value == nullptr) {
return false;
}
Definition* unboxed_result = builder.AddDefinition(new UnaryDoubleOpInstr(
Token::kNEGATE, new Value(unboxed_value), DeoptId::kNone));
Definition* result =
CreateBoxedResultIfNeeded(&builder, unboxed_result, kUnboxedDouble);
builder.AddReturn(new Value(result));
return true;
}
static bool BuildInvokeMathCFunction(FlowGraph* flow_graph,
MethodRecognizer::Kind kind,
intptr_t num_parameters = 1) {
if (!FlowGraphCompiler::SupportsUnboxedDoubles()) {
return false;
}
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
ZoneGrowableArray<Value*>* args =
new ZoneGrowableArray<Value*>(num_parameters);
for (intptr_t i = 0; i < num_parameters; i++) {
Definition* value = builder.AddParameter(i, /*with_frame=*/false);
Definition* unboxed_value = ConvertOrUnboxDoubleParameter(
&builder, value, i, /* is_checked = */ false);
if (unboxed_value == nullptr) {
return false;
}
args->Add(new Value(unboxed_value));
}
Definition* unboxed_result =
builder.AddDefinition(new InvokeMathCFunctionInstr(
args, DeoptId::kNone, kind, builder.Source()));
Definition* result =
CreateBoxedResultIfNeeded(&builder, unboxed_result, kUnboxedDouble);
builder.AddReturn(new Value(result));
return true;
}
bool GraphIntrinsifier::Build_MathSin(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathSin);
}
bool GraphIntrinsifier::Build_MathCos(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathCos);
}
bool GraphIntrinsifier::Build_MathTan(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathTan);
}
bool GraphIntrinsifier::Build_MathAsin(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAsin);
}
bool GraphIntrinsifier::Build_MathAcos(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAcos);
}
bool GraphIntrinsifier::Build_MathAtan(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAtan);
}
bool GraphIntrinsifier::Build_MathAtan2(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathAtan2,
/* num_parameters = */ 2);
}
bool GraphIntrinsifier::Build_MathExp(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathExp);
}
bool GraphIntrinsifier::Build_MathLog(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kMathLog);
}
bool GraphIntrinsifier::Build_DoubleMod(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleMod,
/* num_parameters = */ 2);
}
bool GraphIntrinsifier::Build_DoubleCeil(FlowGraph* flow_graph) {
// TODO(johnmccutchan): On X86 this intrinsic can be written in a different
// way.
if (TargetCPUFeatures::double_truncate_round_supported()) return false;
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleCeil);
}
bool GraphIntrinsifier::Build_DoubleFloor(FlowGraph* flow_graph) {
// TODO(johnmccutchan): On X86 this intrinsic can be written in a different
// way.
if (TargetCPUFeatures::double_truncate_round_supported()) return false;
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleFloor);
}
bool GraphIntrinsifier::Build_DoubleTruncate(FlowGraph* flow_graph) {
// TODO(johnmccutchan): On X86 this intrinsic can be written in a different
// way.
if (TargetCPUFeatures::double_truncate_round_supported()) return false;
return BuildInvokeMathCFunction(flow_graph,
MethodRecognizer::kDoubleTruncate);
}
bool GraphIntrinsifier::Build_DoubleRound(FlowGraph* flow_graph) {
return BuildInvokeMathCFunction(flow_graph, MethodRecognizer::kDoubleRound);
}
bool GraphIntrinsifier::Build_ImplicitGetter(FlowGraph* flow_graph) {
// This code will only be invoked if our assumptions have been met (see
// [Intrinsifier::CanIntrinsifyFieldAccessor])
auto zone = flow_graph->zone();
const auto& function = flow_graph->function();
ASSERT(Intrinsifier::CanIntrinsifyFieldAccessor(function));
auto& field = Field::Handle(zone, function.accessor_field());
if (CompilerState::Current().should_clone_fields()) {
field = field.CloneFromOriginal();
}
ASSERT(field.is_instance() && !field.is_late() && !field.needs_load_guard());
const auto& slot = Slot::Get(field, &flow_graph->parsed_function());
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
auto receiver = builder.AddParameter(0, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
Definition* field_value = builder.AddDefinition(new (zone) LoadFieldInstr(
new (zone) Value(receiver), slot, builder.Source()));
// We only support cases where we do not have to create a box (whose
// allocation could fail).
ASSERT(function.HasUnboxedReturnValue() ||
!FlowGraphCompiler::IsUnboxedField(field));
// We might need to unbox the field value before returning.
if (function.HasUnboxedReturnValue() &&
!FlowGraphCompiler::IsUnboxedField(field)) {
ASSERT(FLAG_precompiled_mode);
field_value = builder.AddUnboxInstr(
FlowGraph::ReturnRepresentationOf(flow_graph->function()),
new Value(field_value), /*is_checked=*/true);
}
builder.AddReturn(new (zone) Value(field_value));
return true;
}
bool GraphIntrinsifier::Build_ImplicitSetter(FlowGraph* flow_graph) {
// This code will only be invoked if our assumptions have been met (see
// [Intrinsifier::CanIntrinsifyFieldAccessor])
auto zone = flow_graph->zone();
const auto& function = flow_graph->function();
ASSERT(Intrinsifier::CanIntrinsifyFieldAccessor(function));
auto& field = Field::Handle(zone, function.accessor_field());
if (CompilerState::Current().should_clone_fields()) {
field = field.CloneFromOriginal();
}
ASSERT(field.is_instance() && !field.is_final());
ASSERT(!function.HasUnboxedParameters() ||
FlowGraphCompiler::IsUnboxedField(field));
const auto& slot = Slot::Get(field, &flow_graph->parsed_function());
const auto barrier_mode = FlowGraphCompiler::IsUnboxedField(field)
? kNoStoreBarrier
: kEmitStoreBarrier;
flow_graph->CreateCommonConstants();
GraphEntryInstr* graph_entry = flow_graph->graph_entry();
auto normal_entry = graph_entry->normal_entry();
BlockBuilder builder(flow_graph, normal_entry);
auto receiver = builder.AddParameter(0, /*with_frame=*/false);
auto value = builder.AddParameter(1, /*with_frame=*/false);
VerifyParameterIsBoxed(&builder, 0);
if (!function.HasUnboxedParameters() &&
FlowGraphCompiler::IsUnboxedField(field)) {
// We do not support storing to possibly guarded fields in JIT in graph
// intrinsics.
ASSERT(FLAG_precompiled_mode);
value = builder.AddUnboxInstr(
FlowGraph::UnboxedFieldRepresentationOf(field), new Value(value),
/*is_checked=*/true);
}
builder.AddInstruction(new (zone) StoreInstanceFieldInstr(
slot, new (zone) Value(receiver), new (zone) Value(value), barrier_mode,
builder.Source()));
builder.AddReturn(new (zone) Value(flow_graph->constant_null()));
return true;
}
} // namespace compiler
} // namespace dart
Reference in New Issue View Git Blame Copy Permalink