SIMD shuffle API changes

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 1674 matching lines @@
   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::kFloat32x4Shuffle) {
+  if ((getter == MethodRecognizer::kFloat32x4Shuffle) ||
+      (getter == MethodRecognizer::kFloat32x4ShuffleMix)) {
     // Extract shuffle mask.
-    ASSERT(call->ArgumentCount() == 2);
-    Definition* mask_definition = call->ArgumentAt(1);
+    Definition* mask_definition = NULL;
+    if (getter == MethodRecognizer::kFloat32x4Shuffle) {
+      ASSERT(call->ArgumentCount() == 2);
+      mask_definition = call->ArgumentAt(1);
+    } else {
+      ASSERT(getter == MethodRecognizer::kFloat32x4ShuffleMix);
+      ASSERT(call->ArgumentCount() == 3);
+      mask_definition = call->ArgumentAt(2);
+    }
     if (!mask_definition->IsConstant()) {
-      // Not a constant.
       return false;
     }
     ASSERT(mask_definition->IsConstant());
     ConstantInstr* constant_instruction = mask_definition->AsConstant();
     const Object& constant_mask = constant_instruction->value();
     if (!constant_mask.IsSmi()) {
-      // Not a smi.
       return false;
     }
     ASSERT(constant_mask.IsSmi());
     mask = Smi::Cast(constant_mask).Value();
-    if (mask < 0 || mask > 255) {
+    if ((mask < 0) || (mask > 255)) {
       // Not a valid mask.
       return false;
     }
   }
   if (getter == MethodRecognizer::kFloat32x4GetSignMask) {
     Simd32x4GetSignMaskInstr* instr = new Simd32x4GetSignMaskInstr(
         getter,
         new Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
+  } else if (getter == MethodRecognizer::kFloat32x4ShuffleMix) {
+    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 {
     ASSERT((getter == MethodRecognizer::kFloat32x4Shuffle)  ||
            (getter == MethodRecognizer::kFloat32x4ShuffleX) ||
            (getter == MethodRecognizer::kFloat32x4ShuffleY) ||
            (getter == MethodRecognizer::kFloat32x4ShuffleZ) ||
            (getter == MethodRecognizer::kFloat32x4ShuffleW));
-    Float32x4ShuffleInstr* instr = new Float32x4ShuffleInstr(
+    Simd32x4ShuffleInstr* instr = new Simd32x4ShuffleInstr(
         getter,
         new Value(call->ArgumentAt(0)),
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
 
 bool FlowGraphOptimizer::InlineUint32x4Getter(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)) {
+    // Extract shuffle mask.
+    Definition* mask_definition = NULL;
+    if (getter == MethodRecognizer::kUint32x4Shuffle) {
+      ASSERT(call->ArgumentCount() == 2);
+      mask_definition = call->ArgumentAt(1);
+    } else {
+      ASSERT(getter == MethodRecognizer::kUint32x4ShuffleMix);
+      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) {
     Simd32x4GetSignMaskInstr* instr = new Simd32x4GetSignMaskInstr(
         getter,
         new Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
+  } else if (getter == MethodRecognizer::kUint32x4ShuffleMix) {
+    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) {
+    Simd32x4ShuffleInstr* instr = new Simd32x4ShuffleInstr(
+        getter,
+        new Value(call->ArgumentAt(0)),
+        mask,
+        call->deopt_id());
+    ReplaceCall(call, instr);
+    return true;
   } else {
     Uint32x4GetFlagInstr* instr = new Uint32x4GetFlagInstr(
         getter,
         new Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
 }
 
@@ skipping 542 matching lines @@
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4MinMaxInstr* minmax =
           new Float32x4MinMaxInstr(recognized_kind, new Value(left),
                                    new Value(right), call->deopt_id());
       ReplaceCall(call, minmax);
       return true;
     }
-    case MethodRecognizer::kFloat32x4WithZWInXY:
-    case MethodRecognizer::kFloat32x4InterleaveXY:
-    case MethodRecognizer::kFloat32x4InterleaveZW:
-    case MethodRecognizer::kFloat32x4InterleaveXYPairs:
-    case MethodRecognizer::kFloat32x4InterleaveZWPairs: {
-      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);
-      Float32x4TwoArgShuffleInstr* two_arg_shuffle =
-          new Float32x4TwoArgShuffleInstr(recognized_kind, new Value(left),
-                                          new Value(right), call->deopt_id());
-      ReplaceCall(call, two_arg_shuffle);
-      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);
@@ skipping 69 matching lines @@
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4ClampInstr* clamp = new Float32x4ClampInstr(new Value(left),
                                                            new Value(lower),
                                                            new Value(upper),
                                                            call->deopt_id());
       ReplaceCall(call, clamp);
       return true;
     }
+    case MethodRecognizer::kFloat32x4ShuffleMix:
     case MethodRecognizer::kFloat32x4Shuffle: {
       return InlineFloat32x4Getter(call, recognized_kind);
     }
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::TryInlineUint32x4Method(
     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));
       ASSERT(call->ic_data()->HasOneTarget());
       return InlineUint32x4Getter(call, recognized_kind);
 
     case MethodRecognizer::kUint32x4Select: {
@@ skipping 4419 matching lines @@
   }
 }
 
 
 void ConstantPropagator::VisitFloat32x4Constructor(
     Float32x4ConstructorInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitFloat32x4Shuffle(Float32x4ShuffleInstr* instr) {
+void ConstantPropagator::VisitSimd32x4Shuffle(Simd32x4ShuffleInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
+
+void ConstantPropagator::VisitSimd32x4ShuffleMix(
+    Simd32x4ShuffleMixInstr* instr) {
+  SetValue(instr, non_constant_);
+}
+
 
 void ConstantPropagator::VisitSimd32x4GetSignMask(
     Simd32x4GetSignMaskInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat32x4Zero(Float32x4ZeroInstr* instr) {
   SetValue(instr, non_constant_);
 }
@@ skipping 39 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat32x4ToUint32x4(
     Float32x4ToUint32x4Instr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitFloat32x4TwoArgShuffle(
-    Float32x4TwoArgShuffleInstr* instr) {
-  SetValue(instr, non_constant_);
-}
-
-
 void ConstantPropagator::VisitUint32x4BoolConstructor(
     Uint32x4BoolConstructorInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUint32x4GetFlag(Uint32x4GetFlagInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
@@ skipping 956 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