Inline Uint32x4 operations

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 538 matching lines @@
 static bool HasOnlyTwoSmis(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid);
 }
 
 static bool HasOnlyTwoFloat32x4s(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       ICDataHasReceiverArgumentClassIds(ic_data, kFloat32x4Cid, kFloat32x4Cid);
 }
 
+static bool HasOnlyTwoUint32x4s(const ICData& ic_data) {
+  return (ic_data.NumberOfChecks() == 1) &&
+      ICDataHasReceiverArgumentClassIds(ic_data, kUint32x4Cid, kUint32x4Cid);
+}
 
 // Returns false if the ICData contains anything other than the 4 combinations
 // of Mint and Smi for the receiver and argument classes.
 static bool HasTwoMintOrSmi(const ICData& ic_data) {
   GrowableArray<intptr_t> class_ids(2);
   class_ids.Add(kSmiCid);
   class_ids.Add(kMintCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
 }
 
@@ skipping 458 matching lines @@
         return false;
       }
       break;
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       if (HasOnlyTwoSmis(ic_data)) {
         operands_type = kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data)) {
         operands_type = kMintCid;
+      } else if (HasOnlyTwoUint32x4s(ic_data)) {
+        operands_type = kUint32x4Cid;
       } else {
         return false;
       }
       break;
     case Token::kSHR:
     case Token::kSHL:
       if (HasOnlyTwoSmis(ic_data)) {
         // 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 66 matching lines @@
     // Type check right.
     AddCheckClass(right,
                   ICData::ZoneHandle(
                       call->ic_data()->AsUnaryClassChecksForArgNr(1)),
                   call->deopt_id(),
                   call->env(),
                   call);
     // Replace call.
     BinaryFloat32x4OpInstr* float32x4_bin_op =
         new BinaryFloat32x4OpInstr(op_kind, new Value(left), new Value(right),
-                                   call);
+                                   call->deopt_id());
     ReplaceCall(call, float32x4_bin_op);
+  } else if (operands_type == kUint32x4Cid) {
+    // 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),
+                                  call->deopt_id());
+    ReplaceCall(call, uint32x4_bin_op);
   } 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 ((value <= 0) || !Utils::IsPowerOfTwo(value)) return false;
 
     // Insert smi check and attach a copy of the original environment
@@ skipping 274 matching lines @@
                                                MethodRecognizer::Kind getter) {
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   Float32x4ShuffleInstr* instr = new Float32x4ShuffleInstr(
       getter,
       new Value(call->ArgumentAt(0)),
-      call);
+      call->deopt_id());
   ReplaceCall(call, instr);
   return true;
 }
+
+
+bool FlowGraphOptimizer::InlineUint32x4Getter(InstanceCallInstr* call,
+                                              MethodRecognizer::Kind getter) {
+  AddCheckClass(call->ArgumentAt(0),
+                ICData::ZoneHandle(
+                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                call->deopt_id(),
+                call->env(),
+                call);
+  Uint32x4GetFlagInstr* instr = new Uint32x4GetFlagInstr(
+      getter,
+      new Value(call->ArgumentAt(0)),
+      call->deopt_id());
+  ReplaceCall(call, instr);
+  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.
     return false;
   }
@@ skipping 56 matching lines @@
     case MethodRecognizer::kFloat32x4ShuffleWWWW:
     case MethodRecognizer::kFloat32x4ShuffleX:
     case MethodRecognizer::kFloat32x4ShuffleY:
     case MethodRecognizer::kFloat32x4ShuffleZ:
     case MethodRecognizer::kFloat32x4ShuffleW:
       if (!ic_data.HasReceiverClassId(kFloat32x4Cid) ||
           !ic_data.HasOneTarget()) {
         return false;
       }
       return InlineFloat32x4Getter(call, recognized_kind);
+    case MethodRecognizer::kUint32x4GetFlagX:
+    case MethodRecognizer::kUint32x4GetFlagY:
+    case MethodRecognizer::kUint32x4GetFlagZ:
+    case MethodRecognizer::kUint32x4GetFlagW: {
+      if (!ic_data.HasReceiverClassId(kUint32x4Cid) ||
+          !ic_data.HasOneTarget()) {
+        return false;
+      }
+      return InlineUint32x4Getter(call, recognized_kind);
+    }
     default:
       ASSERT(recognized_kind == MethodRecognizer::kUnknown);
   }
   return false;
 }
 
 
 LoadIndexedInstr* FlowGraphOptimizer::BuildStringCodeUnitAt(
     InstanceCallInstr* call,
     intptr_t cid) {
@@ skipping 247 matching lines @@
             call, class_ids[0], kTypedDataFloat32x4ArrayCid);
       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);
+  }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   ASSERT(call->HasICData());
   switch (recognized_kind) {
     case MethodRecognizer::kFloat32x4Equal:
     case MethodRecognizer::kFloat32x4GreaterThan:
     case MethodRecognizer::kFloat32x4GreaterThanOrEqual:
     case MethodRecognizer::kFloat32x4LessThan:
     case MethodRecognizer::kFloat32x4LessThanOrEqual:
     case MethodRecognizer::kFloat32x4NotEqual: {
       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);
       // Replace call.
       Float32x4ComparisonInstr* cmp =
           new Float32x4ComparisonInstr(recognized_kind, new Value(left),
-                                       new Value(right), call);
+                                       new Value(right), call->deopt_id());
       ReplaceCall(call, cmp);
       return true;
     }
     case MethodRecognizer::kFloat32x4Min:
     case MethodRecognizer::kFloat32x4Max: {
       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);
       Float32x4MinMaxInstr* minmax =
           new Float32x4MinMaxInstr(recognized_kind, new Value(left),
-                                   new Value(right), call);
+                                   new Value(right), call->deopt_id());
       ReplaceCall(call, minmax);
       return true;
     }
     case MethodRecognizer::kFloat32x4Scale: {
       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);
       // Left and right values are swapped when handed to the instruction,
       // this is done so that the double value is loaded into the output
       // register and can be destroyed.
       Float32x4ScaleInstr* scale =
           new Float32x4ScaleInstr(recognized_kind, new Value(right),
-                                  new Value(left), call);
+                                  new Value(left), call->deopt_id());
       ReplaceCall(call, scale);
       return true;
     }
     case MethodRecognizer::kFloat32x4Sqrt:
     case MethodRecognizer::kFloat32x4ReciprocalSqrt:
     case MethodRecognizer::kFloat32x4Reciprocal: {
       Definition* left = call->ArgumentAt(0);
       AddCheckClass(left,
                     ICData::ZoneHandle(
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4SqrtInstr* sqrt =
-          new Float32x4SqrtInstr(recognized_kind, new Value(left), call);
+          new Float32x4SqrtInstr(recognized_kind, new Value(left),
+                                 call->deopt_id());
       ReplaceCall(call, sqrt);
       return true;
     }
     case MethodRecognizer::kFloat32x4WithX:
     case MethodRecognizer::kFloat32x4WithY:
     case MethodRecognizer::kFloat32x4WithZ:
     case MethodRecognizer::kFloat32x4WithW: {
       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);
       Float32x4WithInstr* with = new Float32x4WithInstr(recognized_kind,
                                                         new Value(left),
                                                         new Value(right),
-                                                        call);
+                                                        call->deopt_id());
       ReplaceCall(call, with);
       return true;
     }
     case MethodRecognizer::kFloat32x4Absolute:
     case MethodRecognizer::kFloat32x4Negate: {
       Definition* left = call->ArgumentAt(0);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4ZeroArgInstr* zeroArg =
-          new Float32x4ZeroArgInstr(recognized_kind, new Value(left), call);
+          new Float32x4ZeroArgInstr(recognized_kind, new Value(left),
+                                    call->deopt_id());
       ReplaceCall(call, zeroArg);
       return true;
     }
     case MethodRecognizer::kFloat32x4Clamp: {
       Definition* left = call->ArgumentAt(0);
       Definition* lower = call->ArgumentAt(1);
       Definition* upper = call->ArgumentAt(2);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4ClampInstr* clamp = new Float32x4ClampInstr(new Value(left),
                                                            new Value(lower),
                                                            new Value(upper),
-                                                           call);
+                                                           call->deopt_id());
       ReplaceCall(call, clamp);
       return true;
     }
     case MethodRecognizer::kFloat32x4ToUint32x4: {
       Definition* left = call->ArgumentAt(0);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4ToUint32x4Instr* cast =
-          new Float32x4ToUint32x4Instr(new Value(left), call);
+          new Float32x4ToUint32x4Instr(new Value(left), call->deopt_id());
       ReplaceCall(call, cast);
       return true;
     }
     default:
       return false;
   }
+}
+
+
+bool FlowGraphOptimizer::TryInlineUint32x4Method(
+    InstanceCallInstr* call,
+    MethodRecognizer::Kind recognized_kind) {
+  ASSERT(call->HasICData());
+  switch (recognized_kind) {
+    case MethodRecognizer::kUint32x4Select: {
+      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(
+          new Value(mask),
+          new Value(trueValue),
+          new Value(falseValue),
+          call->deopt_id());
+      ReplaceCall(call, select);
+      return true;
+    }
+    case MethodRecognizer::kUint32x4ToUint32x4: {
+      Definition* left = call->ArgumentAt(0);
+      // Type check left.
+      AddCheckClass(left,
+                    ICData::ZoneHandle(
+                        call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                    call->deopt_id(),
+                    call->env(),
+                    call);
+      Uint32x4ToFloat32x4Instr* cast =
+          new Uint32x4ToFloat32x4Instr(new Value(left), call->deopt_id());
+      ReplaceCall(call, cast);
+      return true;
+    }
+    case MethodRecognizer::kUint32x4WithFlagX:
+    case MethodRecognizer::kUint32x4WithFlagY:
+    case MethodRecognizer::kUint32x4WithFlagZ:
+    case MethodRecognizer::kUint32x4WithFlagW: {
+      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(
+          recognized_kind,
+          new Value(left),
+          new Value(flag),
+          call->deopt_id());
+      ReplaceCall(call, setFlag);
+      return true;
+    }
+    default:
+      return false;
+  }
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewLoad(
     InstanceCallInstr* call,
     intptr_t receiver_cid,
     intptr_t view_cid) {
   Definition* array = call->ArgumentAt(0);
   PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
 
@@ skipping 362 matching lines @@
 
 
 void FlowGraphOptimizer::VisitStaticCall(StaticCallInstr* call) {
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   if (recognized_kind == MethodRecognizer::kMathSqrt) {
     MathSqrtInstr* sqrt =
         new MathSqrtInstr(new Value(call->ArgumentAt(0)), call);
     ReplaceCall(call, sqrt);
   } else if (recognized_kind == MethodRecognizer::kFloat32x4Zero) {
-    Float32x4ZeroInstr* zero = new Float32x4ZeroInstr(call);
+    Float32x4ZeroInstr* zero = new Float32x4ZeroInstr(call->deopt_id());
     ReplaceCall(call, zero);
   } else if (recognized_kind == MethodRecognizer::kFloat32x4Splat) {
     Float32x4SplatInstr* splat =
-        new Float32x4SplatInstr(new Value(call->ArgumentAt(1)), call);
+        new Float32x4SplatInstr(new Value(call->ArgumentAt(1)),
+                                call->deopt_id());
     ReplaceCall(call, splat);
   } 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);
+                                      call->deopt_id());
+    ReplaceCall(call, con);
+  } else if (recognized_kind == MethodRecognizer::kUint32x4BoolConstructor) {
+    Uint32x4BoolConstructorInstr* con = new Uint32x4BoolConstructorInstr(
+        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);
   }
 }
 
 
 bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                                  const ICData& unary_ic_data) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
       (unary_ic_data.num_args_tested() == 1));
   if (FLAG_enable_type_checks) {
@@ skipping 3036 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat32x4ToUint32x4(
     Float32x4ToUint32x4Instr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitUint32x4BoolConstructor(
+    Uint32x4BoolConstructorInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitUint32x4GetFlag(Uint32x4GetFlagInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitUint32x4SetFlag(Uint32x4SetFlagInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitUint32x4Select(Uint32x4SelectInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitUint32x4ToFloat32x4(
+    Uint32x4ToFloat32x4Instr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitBinaryUint32x4Op(BinaryUint32x4OpInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitMathSqrt(MathSqrtInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle sqrt.
     SetValue(instr, non_constant_);
   }
 }
 
@@ skipping 879 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart