Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(196)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: dart/runtime/vm/flow_graph_optimizer.cc

Issue 59073003: Version 0.8.10.4 (Closed) Base URL: http://dart.googlecode.com/svn/trunk/
Patch Set: Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « dart/runtime/vm/flow_graph_optimizer.h ('k') | dart/runtime/vm/flow_graph_type_propagator.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: dart/runtime/vm/flow_graph_optimizer.cc
===================================================================
--- dart/runtime/vm/flow_graph_optimizer.cc (revision 29808)
+++ dart/runtime/vm/flow_graph_optimizer.cc (working copy)
@@ -393,13 +393,13 @@
converted = new UnboxFloat32x4Instr(use->CopyWithType(), deopt_id);
} else if ((from == kUnboxedFloat32x4) && (to == kTagged)) {
converted = new BoxFloat32x4Instr(use->CopyWithType());
- } else if ((from == kTagged) && (to == kUnboxedUint32x4)) {
- ASSERT((deopt_target != NULL) || (use->Type()->ToCid() == kUint32x4Cid));
+ } else if ((from == kTagged) && (to == kUnboxedInt32x4)) {
+ ASSERT((deopt_target != NULL) || (use->Type()->ToCid() == kInt32x4Cid));
const intptr_t deopt_id = (deopt_target != NULL) ?
deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
- converted = new UnboxUint32x4Instr(use->CopyWithType(), deopt_id);
- } else if ((from == kUnboxedUint32x4) && (to == kTagged)) {
- converted = new BoxUint32x4Instr(use->CopyWithType());
+ converted = new UnboxInt32x4Instr(use->CopyWithType(), deopt_id);
+ } else if ((from == kUnboxedInt32x4) && (to == kTagged)) {
+ converted = new BoxInt32x4Instr(use->CopyWithType());
} else {
// We have failed to find a suitable conversion instruction.
// Insert two "dummy" conversion instructions with the correct
@@ -412,8 +412,8 @@
Definition* boxed = NULL;
if (from == kUnboxedDouble) {
boxed = new BoxDoubleInstr(use->CopyWithType());
- } else if (from == kUnboxedUint32x4) {
- boxed = new BoxUint32x4Instr(use->CopyWithType());
+ } else if (from == kUnboxedInt32x4) {
+ boxed = new BoxInt32x4Instr(use->CopyWithType());
} else if (from == kUnboxedFloat32x4) {
boxed = new BoxFloat32x4Instr(use->CopyWithType());
} else if (from == kUnboxedMint) {
@@ -426,8 +426,8 @@
Value* to_value = new Value(boxed);
if (to == kUnboxedDouble) {
converted = new UnboxDoubleInstr(to_value, deopt_id);
- } else if (to == kUnboxedUint32x4) {
- converted = new UnboxUint32x4Instr(to_value, deopt_id);
+ } else if (to == kUnboxedInt32x4) {
+ converted = new UnboxInt32x4Instr(to_value, deopt_id);
} else if (to == kUnboxedFloat32x4) {
converted = new UnboxFloat32x4Instr(to_value, deopt_id);
} else if (to == kUnboxedMint) {
@@ -492,9 +492,9 @@
unboxed = kUnboxedFloat32x4;
}
break;
- case kUint32x4Cid:
+ case kInt32x4Cid:
if (ShouldInlineSimd()) {
- unboxed = kUnboxedUint32x4;
+ unboxed = kUnboxedInt32x4;
}
break;
}
@@ -510,7 +510,7 @@
void FlowGraphOptimizer::SelectRepresentations() {
// Convervatively unbox all phis that were proven to be of Double,
- // Float32x4, or Uint32x4 type.
+ // Float32x4, or Int32x4 type.
for (intptr_t i = 0; i < block_order_.length(); ++i) {
JoinEntryInstr* join_entry = block_order_[i]->AsJoinEntry();
if (join_entry != NULL) {
@@ -812,9 +812,9 @@
case MethodRecognizer::kFloat32x4ArraySetIndexed:
return kTypedDataFloat32x4ArrayCid;
- case MethodRecognizer::kUint32x4ArrayGetIndexed:
- case MethodRecognizer::kUint32x4ArraySetIndexed:
- return kTypedDataUint32x4ArrayCid;
+ case MethodRecognizer::kInt32x4ArrayGetIndexed:
+ case MethodRecognizer::kInt32x4ArraySetIndexed:
+ return kTypedDataInt32x4ArrayCid;
default:
break;
@@ -976,7 +976,7 @@
: kEmitStoreBarrier;
if (!value_check.IsNull()) {
// No store barrier needed because checked value is a smi, an unboxed mint,
- // an unboxed double, an unboxed Float32x4, or unboxed Uint32x4.
+ // an unboxed double, an unboxed Float32x4, or unboxed Int32x4.
needs_store_barrier = kNoStoreBarrier;
Instruction* check =
GetCheckClass(stored_value, value_check, call->deopt_id());
@@ -1122,10 +1122,10 @@
return InlineByteArrayViewLoad(call, receiver, receiver_cid,
kTypedDataFloat32x4ArrayCid,
ic_data, entry, last);
- case MethodRecognizer::kByteArrayBaseGetUint32x4:
+ case MethodRecognizer::kByteArrayBaseGetInt32x4:
if (!ShouldInlineSimd()) return false;
return InlineByteArrayViewLoad(call, receiver, receiver_cid,
- kTypedDataUint32x4ArrayCid,
+ kTypedDataInt32x4ArrayCid,
ic_data, entry, last);
default:
return false;
@@ -1370,8 +1370,8 @@
operands_type = kDoubleCid;
} else if (HasOnlyTwoOf(ic_data, kFloat32x4Cid)) {
operands_type = kFloat32x4Cid;
- } else if (HasOnlyTwoOf(ic_data, kUint32x4Cid)) {
- operands_type = kUint32x4Cid;
+ } else if (HasOnlyTwoOf(ic_data, kInt32x4Cid)) {
+ operands_type = kInt32x4Cid;
} else {
return false;
}
@@ -1415,8 +1415,8 @@
operands_type = kSmiCid;
} else if (HasTwoMintOrSmi(ic_data)) {
operands_type = kMintCid;
- } else if (HasOnlyTwoOf(ic_data, kUint32x4Cid)) {
- operands_type = kUint32x4Cid;
+ } else if (HasOnlyTwoOf(ic_data, kInt32x4Cid)) {
+ operands_type = kInt32x4Cid;
} else {
return false;
}
@@ -1490,8 +1490,8 @@
}
} else if (operands_type == kFloat32x4Cid) {
return InlineFloat32x4BinaryOp(call, op_kind);
- } else if (operands_type == kUint32x4Cid) {
- return InlineUint32x4BinaryOp(call, op_kind);
+ } else if (operands_type == kInt32x4Cid) {
+ return InlineInt32x4BinaryOp(call, op_kind);
} else if (op_kind == Token::kMOD) {
// TODO(vegorov): implement fast path code for modulo.
ASSERT(operands_type == kSmiCid);
@@ -1755,7 +1755,7 @@
}
-bool FlowGraphOptimizer::InlineUint32x4Getter(InstanceCallInstr* call,
+bool FlowGraphOptimizer::InlineInt32x4Getter(InstanceCallInstr* call,
MethodRecognizer::Kind getter) {
if (!ShouldInlineSimd()) {
return false;
@@ -1767,15 +1767,15 @@
call->env(),
call);
intptr_t mask = 0;
- if ((getter == MethodRecognizer::kUint32x4Shuffle) ||
- (getter == MethodRecognizer::kUint32x4ShuffleMix)) {
+ if ((getter == MethodRecognizer::kInt32x4Shuffle) ||
+ (getter == MethodRecognizer::kInt32x4ShuffleMix)) {
// Extract shuffle mask.
Definition* mask_definition = NULL;
- if (getter == MethodRecognizer::kUint32x4Shuffle) {
+ if (getter == MethodRecognizer::kInt32x4Shuffle) {
ASSERT(call->ArgumentCount() == 2);
mask_definition = call->ArgumentAt(1);
} else {
- ASSERT(getter == MethodRecognizer::kUint32x4ShuffleMix);
+ ASSERT(getter == MethodRecognizer::kInt32x4ShuffleMix);
ASSERT(call->ArgumentCount() == 3);
mask_definition = call->ArgumentAt(2);
}
@@ -1795,14 +1795,14 @@
return false;
}
}
- if (getter == MethodRecognizer::kUint32x4GetSignMask) {
+ if (getter == MethodRecognizer::kInt32x4GetSignMask) {
Simd32x4GetSignMaskInstr* instr = new Simd32x4GetSignMaskInstr(
getter,
new Value(call->ArgumentAt(0)),
call->deopt_id());
ReplaceCall(call, instr);
return true;
- } else if (getter == MethodRecognizer::kUint32x4ShuffleMix) {
+ } else if (getter == MethodRecognizer::kInt32x4ShuffleMix) {
Simd32x4ShuffleMixInstr* instr = new Simd32x4ShuffleMixInstr(
getter,
new Value(call->ArgumentAt(0)),
@@ -1811,7 +1811,7 @@
call->deopt_id());
ReplaceCall(call, instr);
return true;
- } else if (getter == MethodRecognizer::kUint32x4Shuffle) {
+ } else if (getter == MethodRecognizer::kInt32x4Shuffle) {
Simd32x4ShuffleInstr* instr = new Simd32x4ShuffleInstr(
getter,
new Value(call->ArgumentAt(0)),
@@ -1820,7 +1820,7 @@
ReplaceCall(call, instr);
return true;
} else {
- Uint32x4GetFlagInstr* instr = new Uint32x4GetFlagInstr(
+ Int32x4GetFlagInstr* instr = new Int32x4GetFlagInstr(
getter,
new Value(call->ArgumentAt(0)),
call->deopt_id());
@@ -1862,7 +1862,7 @@
}
-bool FlowGraphOptimizer::InlineUint32x4BinaryOp(InstanceCallInstr* call,
+bool FlowGraphOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
Token::Kind op_kind) {
if (!ShouldInlineSimd()) {
return false;
@@ -1885,10 +1885,10 @@
call->env(),
call);
// Replace call.
- BinaryUint32x4OpInstr* uint32x4_bin_op =
- new BinaryUint32x4OpInstr(op_kind, new Value(left), new Value(right),
+ BinaryInt32x4OpInstr* int32x4_bin_op =
+ new BinaryInt32x4OpInstr(op_kind, new Value(left), new Value(right),
call->deopt_id());
- ReplaceCall(call, uint32x4_bin_op);
+ ReplaceCall(call, int32x4_bin_op);
return true;
}
@@ -1987,7 +1987,7 @@
case kTypedDataFloat32ArrayCid:
case kTypedDataFloat64ArrayCid:
case kTypedDataFloat32x4ArrayCid:
- case kTypedDataUint32x4ArrayCid:
+ case kTypedDataInt32x4ArrayCid:
return true;
default:
return false;
@@ -2161,8 +2161,8 @@
return BuildByteArrayViewLoad(call, kTypedDataFloat64ArrayCid);
case MethodRecognizer::kByteArrayBaseGetFloat32x4:
return BuildByteArrayViewLoad(call, kTypedDataFloat32x4ArrayCid);
- case MethodRecognizer::kByteArrayBaseGetUint32x4:
- return BuildByteArrayViewLoad(call, kTypedDataUint32x4ArrayCid);
+ case MethodRecognizer::kByteArrayBaseGetInt32x4:
+ return BuildByteArrayViewLoad(call, kTypedDataInt32x4ArrayCid);
// ByteArray setters.
case MethodRecognizer::kByteArrayBaseSetInt8:
@@ -2183,8 +2183,8 @@
return BuildByteArrayViewStore(call, kTypedDataFloat64ArrayCid);
case MethodRecognizer::kByteArrayBaseSetFloat32x4:
return BuildByteArrayViewStore(call, kTypedDataFloat32x4ArrayCid);
- case MethodRecognizer::kByteArrayBaseSetUint32x4:
- return BuildByteArrayViewStore(call, kTypedDataUint32x4ArrayCid);
+ case MethodRecognizer::kByteArrayBaseSetInt32x4:
+ return BuildByteArrayViewStore(call, kTypedDataInt32x4ArrayCid);
default:
// Unsupported method.
return false;
@@ -2195,8 +2195,8 @@
return TryInlineFloat32x4Method(call, recognized_kind);
}
- if ((class_ids[0] == kUint32x4Cid) && (ic_data.NumberOfChecks() == 1)) {
- return TryInlineUint32x4Method(call, recognized_kind);
+ if ((class_ids[0] == kInt32x4Cid) && (ic_data.NumberOfChecks() == 1)) {
+ return TryInlineInt32x4Method(call, recognized_kind);
}
if (recognized_kind == MethodRecognizer::kIntegerLeftShiftWithMask32) {
@@ -2288,9 +2288,9 @@
call->deopt_id());
ReplaceCall(call, con);
return true;
- } else if (recognized_kind == MethodRecognizer::kFloat32x4FromUint32x4Bits) {
- Uint32x4ToFloat32x4Instr* cast =
- new Uint32x4ToFloat32x4Instr(new Value(call->ArgumentAt(1)),
+ } else if (recognized_kind == MethodRecognizer::kFloat32x4FromInt32x4Bits) {
+ Int32x4ToFloat32x4Instr* cast =
+ new Int32x4ToFloat32x4Instr(new Value(call->ArgumentAt(1)),
call->deopt_id());
ReplaceCall(call, cast);
return true;
@@ -2299,14 +2299,14 @@
}
-bool FlowGraphOptimizer::TryInlineUint32x4Constructor(
+bool FlowGraphOptimizer::TryInlineInt32x4Constructor(
StaticCallInstr* call,
MethodRecognizer::Kind recognized_kind) {
if (!ShouldInlineSimd()) {
return false;
}
- if (recognized_kind == MethodRecognizer::kUint32x4BoolConstructor) {
- Uint32x4BoolConstructorInstr* con = new Uint32x4BoolConstructorInstr(
+ if (recognized_kind == MethodRecognizer::kInt32x4BoolConstructor) {
+ Int32x4BoolConstructorInstr* con = new Int32x4BoolConstructorInstr(
new Value(call->ArgumentAt(1)),
new Value(call->ArgumentAt(2)),
new Value(call->ArgumentAt(3)),
@@ -2314,9 +2314,9 @@
call->deopt_id());
ReplaceCall(call, con);
return true;
- } else if (recognized_kind == MethodRecognizer::kUint32x4FromFloat32x4Bits) {
- Float32x4ToUint32x4Instr* cast =
- new Float32x4ToUint32x4Instr(new Value(call->ArgumentAt(1)),
+ } else if (recognized_kind == MethodRecognizer::kInt32x4FromFloat32x4Bits) {
+ Float32x4ToInt32x4Instr* cast =
+ new Float32x4ToInt32x4Instr(new Value(call->ArgumentAt(1)),
call->deopt_id());
ReplaceCall(call, cast);
return true;
@@ -2480,7 +2480,7 @@
}
-bool FlowGraphOptimizer::TryInlineUint32x4Method(
+bool FlowGraphOptimizer::TryInlineInt32x4Method(
InstanceCallInstr* call,
MethodRecognizer::Kind recognized_kind) {
if (!ShouldInlineSimd()) {
@@ -2488,18 +2488,18 @@
}
ASSERT(call->HasICData());
switch (recognized_kind) {
- case MethodRecognizer::kUint32x4ShuffleMix:
- case MethodRecognizer::kUint32x4Shuffle:
- case MethodRecognizer::kUint32x4GetFlagX:
- case MethodRecognizer::kUint32x4GetFlagY:
- case MethodRecognizer::kUint32x4GetFlagZ:
- case MethodRecognizer::kUint32x4GetFlagW:
- case MethodRecognizer::kUint32x4GetSignMask:
- ASSERT(call->ic_data()->HasReceiverClassId(kUint32x4Cid));
+ case MethodRecognizer::kInt32x4ShuffleMix:
+ case MethodRecognizer::kInt32x4Shuffle:
+ case MethodRecognizer::kInt32x4GetFlagX:
+ case MethodRecognizer::kInt32x4GetFlagY:
+ case MethodRecognizer::kInt32x4GetFlagZ:
+ case MethodRecognizer::kInt32x4GetFlagW:
+ case MethodRecognizer::kInt32x4GetSignMask:
+ ASSERT(call->ic_data()->HasReceiverClassId(kInt32x4Cid));
ASSERT(call->ic_data()->HasOneTarget());
- return InlineUint32x4Getter(call, recognized_kind);
+ return InlineInt32x4Getter(call, recognized_kind);
- case MethodRecognizer::kUint32x4Select: {
+ case MethodRecognizer::kInt32x4Select: {
Definition* mask = call->ArgumentAt(0);
Definition* trueValue = call->ArgumentAt(1);
Definition* falseValue = call->ArgumentAt(2);
@@ -2510,7 +2510,7 @@
call->deopt_id(),
call->env(),
call);
- Uint32x4SelectInstr* select = new Uint32x4SelectInstr(
+ Int32x4SelectInstr* select = new Int32x4SelectInstr(
new Value(mask),
new Value(trueValue),
new Value(falseValue),
@@ -2518,10 +2518,10 @@
ReplaceCall(call, select);
return true;
}
- case MethodRecognizer::kUint32x4WithFlagX:
- case MethodRecognizer::kUint32x4WithFlagY:
- case MethodRecognizer::kUint32x4WithFlagZ:
- case MethodRecognizer::kUint32x4WithFlagW: {
+ case MethodRecognizer::kInt32x4WithFlagX:
+ case MethodRecognizer::kInt32x4WithFlagY:
+ case MethodRecognizer::kInt32x4WithFlagZ:
+ case MethodRecognizer::kInt32x4WithFlagW: {
Definition* left = call->ArgumentAt(0);
Definition* flag = call->ArgumentAt(1);
// Type check left.
@@ -2531,7 +2531,7 @@
call->deopt_id(),
call->env(),
call);
- Uint32x4SetFlagInstr* setFlag = new Uint32x4SetFlagInstr(
+ Int32x4SetFlagInstr* setFlag = new Int32x4SetFlagInstr(
recognized_kind,
new Value(left),
new Value(flag),
@@ -2675,7 +2675,7 @@
bool FlowGraphOptimizer::BuildByteArrayViewLoad(InstanceCallInstr* call,
intptr_t view_cid) {
bool simd_view = (view_cid == kTypedDataFloat32x4ArrayCid) ||
- (view_cid == kTypedDataUint32x4ArrayCid);
+ (view_cid == kTypedDataInt32x4ArrayCid);
if (simd_view && !ShouldInlineSimd()) {
return false;
}
@@ -2725,7 +2725,7 @@
bool FlowGraphOptimizer::BuildByteArrayViewStore(InstanceCallInstr* call,
intptr_t view_cid) {
bool simd_view = (view_cid == kTypedDataFloat32x4ArrayCid) ||
- (view_cid == kTypedDataUint32x4ArrayCid);
+ (view_cid == kTypedDataInt32x4ArrayCid);
if (simd_view && !ShouldInlineSimd()) {
return false;
}
@@ -2780,14 +2780,14 @@
value_check.AddReceiverCheck(kDoubleCid, target);
break;
}
- case kTypedDataUint32x4ArrayCid: {
- // Check that value is always Uint32x4.
+ case kTypedDataInt32x4ArrayCid: {
+ // Check that value is always Int32x4.
value_check = ICData::New(flow_graph_->parsed_function().function(),
call->function_name(),
Object::empty_array(), // Dummy args. descr.
Isolate::kNoDeoptId,
1);
- value_check.AddReceiverCheck(kUint32x4Cid, target);
+ value_check.AddReceiverCheck(kInt32x4Cid, target);
break;
}
case kTypedDataFloat32x4ArrayCid: {
@@ -3136,8 +3136,8 @@
(recognized_kind == MethodRecognizer::kFloat32x4Splat) ||
(recognized_kind == MethodRecognizer::kFloat32x4Constructor)) {
TryInlineFloat32x4Constructor(call, recognized_kind);
- } else if (recognized_kind == MethodRecognizer::kUint32x4BoolConstructor) {
- TryInlineUint32x4Constructor(call, recognized_kind);
+ } else if (recognized_kind == MethodRecognizer::kInt32x4BoolConstructor) {
+ TryInlineInt32x4Constructor(call, recognized_kind);
} else if (recognized_kind == MethodRecognizer::kObjectConstructor) {
// Remove the original push arguments.
for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
@@ -6992,40 +6992,40 @@
}
-void ConstantPropagator::VisitFloat32x4ToUint32x4(
- Float32x4ToUint32x4Instr* instr) {
+void ConstantPropagator::VisitFloat32x4ToInt32x4(
+ Float32x4ToInt32x4Instr* instr) {
SetValue(instr, non_constant_);
}
-void ConstantPropagator::VisitUint32x4BoolConstructor(
- Uint32x4BoolConstructorInstr* instr) {
+void ConstantPropagator::VisitInt32x4BoolConstructor(
+ Int32x4BoolConstructorInstr* instr) {
SetValue(instr, non_constant_);
}
-void ConstantPropagator::VisitUint32x4GetFlag(Uint32x4GetFlagInstr* instr) {
+void ConstantPropagator::VisitInt32x4GetFlag(Int32x4GetFlagInstr* instr) {
SetValue(instr, non_constant_);
}
-void ConstantPropagator::VisitUint32x4SetFlag(Uint32x4SetFlagInstr* instr) {
+void ConstantPropagator::VisitInt32x4SetFlag(Int32x4SetFlagInstr* instr) {
SetValue(instr, non_constant_);
}
-void ConstantPropagator::VisitUint32x4Select(Uint32x4SelectInstr* instr) {
+void ConstantPropagator::VisitInt32x4Select(Int32x4SelectInstr* instr) {
SetValue(instr, non_constant_);
}
-void ConstantPropagator::VisitUint32x4ToFloat32x4(
- Uint32x4ToFloat32x4Instr* instr) {
+void ConstantPropagator::VisitInt32x4ToFloat32x4(
+ Int32x4ToFloat32x4Instr* instr) {
SetValue(instr, non_constant_);
}
-void ConstantPropagator::VisitBinaryUint32x4Op(BinaryUint32x4OpInstr* instr) {
+void ConstantPropagator::VisitBinaryInt32x4Op(BinaryInt32x4OpInstr* instr) {
SetValue(instr, non_constant_);
}
@@ -7097,7 +7097,7 @@
}
-void ConstantPropagator::VisitUnboxUint32x4(UnboxUint32x4Instr* instr) {
+void ConstantPropagator::VisitUnboxInt32x4(UnboxInt32x4Instr* instr) {
const Object& value = instr->value()->definition()->constant_value();
if (IsNonConstant(value)) {
SetValue(instr, non_constant_);
@@ -7108,7 +7108,7 @@
}
-void ConstantPropagator::VisitBoxUint32x4(BoxUint32x4Instr* instr) {
+void ConstantPropagator::VisitBoxInt32x4(BoxInt32x4Instr* instr) {
const Object& value = instr->value()->definition()->constant_value();
if (IsNonConstant(value)) {
SetValue(instr, non_constant_);
« no previous file with comments | « dart/runtime/vm/flow_graph_optimizer.h ('k') | dart/runtime/vm/flow_graph_type_propagator.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698