Version 0.8.10.4

dart/runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 375 matching lines @@
       converted = new UnboxDoubleInstr(use->CopyWithType(), deopt_id);
     }
   } else if ((from == kTagged) && (to == kUnboxedFloat32x4)) {
     ASSERT((deopt_target != NULL) ||
            (use->Type()->ToCid() == kFloat32x4Cid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     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
     // "from" and "to" representation. The inserted instructions will
     // trigger a deoptimization if executed. See #12417 for a discussion.
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     ASSERT(from != kTagged);
     ASSERT(to != kTagged);
     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) {
       boxed = new BoxIntegerInstr(use->CopyWithType());
     } else {
       UNIMPLEMENTED();
     }
     use->BindTo(boxed);
     InsertBefore(insert_before, boxed, NULL, Definition::kValue);
     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) {
       converted = new UnboxIntegerInstr(to_value, deopt_id);
     } else {
       UNIMPLEMENTED();
     }
   }
   ASSERT(converted != NULL);
   use->BindTo(converted);
@@ skipping 44 matching lines @@
 
   switch (phi->Type()->ToCid()) {
     case kDoubleCid:
       unboxed = kUnboxedDouble;
       break;
     case kFloat32x4Cid:
       if (ShouldInlineSimd()) {
         unboxed = kUnboxedFloat32x4;
       }
       break;
-    case kUint32x4Cid:
+    case kInt32x4Cid:
       if (ShouldInlineSimd()) {
-        unboxed = kUnboxedUint32x4;
+        unboxed = kUnboxedInt32x4;
       }
       break;
   }
 
   if (unboxed != current) {
     phi->set_representation(unboxed);
     return true;
   }
 
   return false;
 }
 
 
 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) {
       for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         UnboxPhi(phi);
       }
     }
   }
 
@@ skipping 281 matching lines @@
       return kTypedDataInt32ArrayCid;
 
     case MethodRecognizer::kUint32ArrayGetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed:
       return kTypedDataUint32ArrayCid;
 
     case MethodRecognizer::kFloat32x4ArrayGetIndexed:
     case MethodRecognizer::kFloat32x4ArraySetIndexed:
       return kTypedDataFloat32x4ArrayCid;
 
-    case MethodRecognizer::kUint32x4ArrayGetIndexed:
-    case MethodRecognizer::kUint32x4ArraySetIndexed:
-      return kTypedDataUint32x4ArrayCid;
+    case MethodRecognizer::kInt32x4ArrayGetIndexed:
+    case MethodRecognizer::kInt32x4ArraySetIndexed:
+      return kTypedDataInt32x4ArrayCid;
 
     default:
       break;
   }
   return kIllegalCid;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithStoreIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
@@ skipping 141 matching lines @@
                                      &cursor);
 
   // Check if store barrier is needed. Byte arrays don't need a store barrier.
   StoreBarrierType needs_store_barrier =
       (RawObject::IsTypedDataClassId(array_cid) ||
        RawObject::IsTypedDataViewClassId(array_cid) ||
        RawObject::IsExternalTypedDataClassId(array_cid)) ? kNoStoreBarrier
                                                          : 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());
     cursor = flow_graph()->AppendTo(cursor,
                                     check,
                                     call->env(),
                                     Definition::kEffect);
   }
 
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
@@ skipping 125 matching lines @@
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat64:
       return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat64ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat32x4:
       if (!ShouldInlineSimd()) return false;
       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;
   }
 }
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineIndexedOp(Instruction* call,
                                                     intptr_t array_cid,
                                                     Definition** array,
@@ skipping 224 matching lines @@
       } else if (HasTwoMintOrSmi(ic_data) &&
                  FlowGraphCompiler::SupportsUnboxedMints()) {
         // Don't generate mint code if the IC data is marked because of an
         // overflow.
         if (ic_data.deopt_reason() == kDeoptBinaryMintOp) return false;
         operands_type = kMintCid;
       } else if (ShouldSpecializeForDouble(ic_data)) {
         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;
       }
       break;
     case Token::kMUL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Don't generate smi code if the IC data is marked because of an
         // overflow.
         // TODO(fschneider): Add unboxed mint multiplication.
         if (ic_data.deopt_reason() == kDeoptBinarySmiOp) return false;
@@ skipping 23 matching lines @@
         return false;
       }
       break;
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         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;
       }
       break;
     case Token::kSHR:
     case Token::kSHL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Left shift may overflow from smi into mint or big ints.
         // Don't generate smi code if the IC data is marked because
         // of an overflow.
@@ skipping 53 matching lines @@
                                call->deopt_id());
       ReplaceCall(call, shift_op);
     } else {
       BinaryMintOpInstr* bin_op =
           new BinaryMintOpInstr(op_kind, new Value(left), new Value(right),
                                 call->deopt_id());
       ReplaceCall(call, bin_op);
     }
   } 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);
     if (!right->IsConstant()) return false;
     const Object& obj = right->AsConstant()->value();
     if (!obj.IsSmi()) return false;
     const intptr_t value = Smi::Cast(obj).Value();
     if (!Utils::IsPowerOfTwo(value)) return false;
 
     // Insert smi check and attach a copy of the original environment
@@ skipping 243 matching lines @@
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
 
-bool FlowGraphOptimizer::InlineUint32x4Getter(InstanceCallInstr* call,
+bool FlowGraphOptimizer::InlineInt32x4Getter(InstanceCallInstr* call,
                                               MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 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);
     }
     if (!mask_definition->IsConstant()) {
       return false;
     }
     ASSERT(mask_definition->IsConstant());
     ConstantInstr* constant_instruction = mask_definition->AsConstant();
     const Object& constant_mask = constant_instruction->value();
     if (!constant_mask.IsSmi()) {
       return false;
     }
     ASSERT(constant_mask.IsSmi());
     mask = Smi::Cast(constant_mask).Value();
     if ((mask < 0) || (mask > 255)) {
       // Not a valid mask.
       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)),
         new Value(call->ArgumentAt(1)),
         mask,
         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)),
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   } else {
-    Uint32x4GetFlagInstr* instr = new Uint32x4GetFlagInstr(
+    Int32x4GetFlagInstr* instr = new Int32x4GetFlagInstr(
         getter,
         new Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
 }
 
 
 bool FlowGraphOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
@@ skipping 21 matching lines @@
   // Replace call.
   BinaryFloat32x4OpInstr* float32x4_bin_op =
       new BinaryFloat32x4OpInstr(op_kind, new Value(left), new Value(right),
                                  call->deopt_id());
   ReplaceCall(call, float32x4_bin_op);
 
   return true;
 }
 
 
-bool FlowGraphOptimizer::InlineUint32x4BinaryOp(InstanceCallInstr* call,
+bool FlowGraphOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
                                                 Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left.
   AddCheckClass(left,
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   // Type check right.
   AddCheckClass(right,
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(1)),
                 call->deopt_id(),
                 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;
 }
 
 
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
@@ skipping 78 matching lines @@
     case kExternalTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
-    case kTypedDataUint32x4ArrayCid:
+    case kTypedDataInt32x4ArrayCid:
       return true;
     default:
       return false;
   }
 }
 
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
@@ skipping 153 matching lines @@
       case MethodRecognizer::kByteArrayBaseGetInt32:
         return BuildByteArrayViewLoad(call, kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetUint32:
         return BuildByteArrayViewLoad(call, kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat32:
         return BuildByteArrayViewLoad(call, kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat64:
         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:
         return BuildByteArrayViewStore(call, kTypedDataInt8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint8:
         return BuildByteArrayViewStore(call, kTypedDataUint8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt16:
         return BuildByteArrayViewStore(call, kTypedDataInt16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint16:
         return BuildByteArrayViewStore(call, kTypedDataUint16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt32:
         return BuildByteArrayViewStore(call, kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint32:
         return BuildByteArrayViewStore(call, kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat32:
         return BuildByteArrayViewStore(call, kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat64:
         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;
     }
   }
 
   if ((class_ids[0] == kFloat32x4Cid) && (ic_data.NumberOfChecks() == 1)) {
     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) {
     ASSERT(call->ArgumentCount() == 3);
     ASSERT(ic_data.num_args_tested() == 2);
     Definition* value = call->ArgumentAt(0);
     Definition* count = call->ArgumentAt(1);
     Definition* int32_mask = call->ArgumentAt(2);
     if (HasOnlyTwoOf(ic_data, kSmiCid)) {
       if (ic_data.deopt_reason() == kDeoptShiftMintOp) {
@@ skipping 71 matching lines @@
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat32x4Constructor) {
     Float32x4ConstructorInstr* con =
         new Float32x4ConstructorInstr(new Value(call->ArgumentAt(1)),
                                       new Value(call->ArgumentAt(2)),
                                       new Value(call->ArgumentAt(3)),
                                       new Value(call->ArgumentAt(4)),
                                       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;
   }
   return false;
 }
 
 
-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)),
         new Value(call->ArgumentAt(4)),
         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;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat32x4Method(
     InstanceCallInstr* call,
@@ skipping 143 matching lines @@
     case MethodRecognizer::kFloat32x4ShuffleMix:
     case MethodRecognizer::kFloat32x4Shuffle: {
       return InlineFloat32x4Getter(call, recognized_kind);
     }
     default:
       return false;
   }
 }
 
 
-bool FlowGraphOptimizer::TryInlineUint32x4Method(
+bool FlowGraphOptimizer::TryInlineInt32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   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);
       // Type check left.
       AddCheckClass(mask,
                     ICData::ZoneHandle(
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
-      Uint32x4SelectInstr* select = new Uint32x4SelectInstr(
+      Int32x4SelectInstr* select = new Int32x4SelectInstr(
           new Value(mask),
           new Value(trueValue),
           new Value(falseValue),
           call->deopt_id());
       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.
       AddCheckClass(left,
                     ICData::ZoneHandle(
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
-      Uint32x4SetFlagInstr* setFlag = new Uint32x4SetFlagInstr(
+      Int32x4SetFlagInstr* setFlag = new Int32x4SetFlagInstr(
           recognized_kind,
           new Value(left),
           new Value(flag),
           call->deopt_id());
       ReplaceCall(call, setFlag);
       return true;
     }
     default:
       return false;
   }
@@ skipping 123 matching lines @@
                                      Definition::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 
 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;
   }
 
   ASSERT(call->HasICData());
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
@@ skipping 29 matching lines @@
   current_iterator()->RemoveCurrentFromGraph();
   call->set_previous(NULL);
   call->set_next(NULL);
   return true;
 }
 
 
 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;
   }
   ASSERT(call->HasICData());
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
   Definition* array = call->ArgumentAt(0);
@@ skipping 34 matching lines @@
     case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
       value_check = ICData::New(flow_graph_->parsed_function().function(),
                                 call->function_name(),
                                 Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
       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: {
       // Check that value is always Float32x4.
       value_check = ICData::New(flow_graph_->parsed_function().function(),
                                 call->function_name(),
                                 Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kFloat32x4Cid, target);
@@ skipping 328 matching lines @@
       (recognized_kind == MethodRecognizer::kMathCos)) {
     MathUnaryInstr* math_unary =
         new MathUnaryInstr(recognized_kind,
                            new Value(call->ArgumentAt(0)),
                            call->deopt_id());
     ReplaceCall(call, math_unary);
   } else if ((recognized_kind == MethodRecognizer::kFloat32x4Zero) ||
              (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) {
       PushArgumentInstr* push = call->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
     }
     // Manually replace call with global null constant. ReplaceCall can't
     // be used for definitions that are already in the graph.
     call->ReplaceUsesWith(flow_graph_->constant_null());
@@ skipping 3834 matching lines @@
 void ConstantPropagator::VisitFloat32x4Clamp(Float32x4ClampInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat32x4With(Float32x4WithInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
-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_);
 }
 
 
 void ConstantPropagator::VisitMathUnary(MathUnaryInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle Math's unary operations (sqrt, cos, sin).
@@ skipping 51 matching lines @@
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle conversion.
     SetValue(instr, non_constant_);
   }
 }
 
 
-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_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle conversion.
     SetValue(instr, non_constant_);
   }
 }
 
 
-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_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle conversion.
     SetValue(instr, non_constant_);
   }
 }
 
 
@@ skipping 845 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart