SIMD shuffle API changes

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 77 matching lines @@
   V(::, cos, MathCos, 1282146521)                                              \
   V(::, min, MathMin, 1830216388)                                              \
   V(::, max, MathMax, 234565686)                                               \
   V(::, _doublePow, MathDoublePow, 1728171041)                                 \
   V(Float32x4, Float32x4., Float32x4Constructor, 786169160)                    \
   V(Float32x4, Float32x4.zero, Float32x4Zero, 1589383280)                      \
   V(Float32x4, Float32x4.splat, Float32x4Splat, 62513275)                      \
   V(Float32x4, Float32x4.fromUint32x4Bits, Float32x4FromUint32x4Bits,          \
       770033146)                                                               \
   V(_Float32x4, shuffle, Float32x4Shuffle, 1178727105)                         \
+  V(_Float32x4, shuffleMix, Float32x4ShuffleMix, 927956119)                    \
   V(_Float32x4, get:x, Float32x4ShuffleX, 1351717838)                          \
   V(_Float32x4, get:y, Float32x4ShuffleY, 217386410)                           \
   V(_Float32x4, get:z, Float32x4ShuffleZ, 2144923721)                          \
   V(_Float32x4, get:w, Float32x4ShuffleW, 1447699119)                          \
   V(_Float32x4, get:signMask, Float32x4GetSignMask, 1198849347)                \
   V(_Float32x4, _cmpequal, Float32x4Equal, 2141256163)                         \
   V(_Float32x4, _cmpgt, Float32x4GreaterThan, 696292270)                       \
   V(_Float32x4, _cmpgte, Float32x4GreaterThanOrEqual, 1199333164)              \
   V(_Float32x4, _cmplt, Float32x4LessThan, 943396590)                          \
   V(_Float32x4, _cmplte, Float32x4LessThanOrEqual, 57211241)                   \
   V(_Float32x4, _cmpnequal, Float32x4NotEqual, 1234888884)                     \
   V(_Float32x4, _min, Float32x4Min, 1166664658)                                \
   V(_Float32x4, _max, Float32x4Max, 343968921)                                 \
   V(_Float32x4, _scale, Float32x4Scale, 803505531)                             \
   V(_Float32x4, _sqrt, Float32x4Sqrt, 2092250151)                              \
   V(_Float32x4, _reciprocalSqrt, Float32x4ReciprocalSqrt, 965252704)           \
   V(_Float32x4, _reciprocal, Float32x4Reciprocal, 1262202915)                  \
   V(_Float32x4, _negate, Float32x4Negate, 1203192635)                          \
   V(_Float32x4, _abs, Float32x4Absolute, 386324188)                            \
   V(_Float32x4, _clamp, Float32x4Clamp, 1454612345)                            \
   V(_Float32x4, withX, Float32x4WithX, 795284225)                              \
   V(_Float32x4, withY, Float32x4WithY, 1806065938)                             \
   V(_Float32x4, withZ, Float32x4WithZ, 320659034)                              \
   V(_Float32x4, withW, Float32x4WithW, 1108437255)                             \
-  V(_Float32x4, withZWInXY, Float32x4WithZWInXY, 1198101679)                   \
-  V(_Float32x4, interleaveXY, Float32x4InterleaveXY, 2001324072)               \
-  V(_Float32x4, interleaveZW, Float32x4InterleaveZW, 928280031)                \
-  V(_Float32x4, interleaveXYPairs, Float32x4InterleaveXYPairs, 1046078993)     \
-  V(_Float32x4, interleaveZWPairs, Float32x4InterleaveZWPairs, 1001751955)     \
   V(Uint32x4, Uint32x4.bool, Uint32x4BoolConstructor, 517444095)               \
   V(Uint32x4, Uint32x4.fromFloat32x4Bits, Uint32x4FromFloat32x4Bits,           \
       1080034855)                                                              \
   V(_Uint32x4, get:flagX, Uint32x4GetFlagX, 1674696792)                        \
   V(_Uint32x4, get:flagY, Uint32x4GetFlagY, 2013200152)                        \
   V(_Uint32x4, get:flagZ, Uint32x4GetFlagZ, 944733935)                         \
   V(_Uint32x4, get:flagW, Uint32x4GetFlagW, 22746169)                          \
   V(_Uint32x4, get:signMask, Uint32x4GetSignMask, 1858144083)                  \
+  V(_Uint32x4, shuffle, Uint32x4Shuffle, 146209630)                            \
+  V(_Uint32x4, shuffleMix, Uint32x4ShuffleMix, 1251494596)                     \
   V(_Uint32x4, select, Uint32x4Select, 72244182)                               \
   V(_Uint32x4, withFlagX, Uint32x4WithFlagX, 1475542073)                       \
   V(_Uint32x4, withFlagY, Uint32x4WithFlagY, 830610988)                        \
   V(_Uint32x4, withFlagZ, Uint32x4WithFlagZ, 1714792414)                       \
   V(_Uint32x4, withFlagW, Uint32x4WithFlagW, 1516924162)                       \
   V(_List, [], ObjectArrayGetIndexed, 1079829188)                              \
   V(_List, []=, ObjectArraySetIndexed, 748954698)                              \
   V(_ImmutableList, [], ImmutableArrayGetIndexed, 25983597)                    \
   V(_GrowableList, [], GrowableArrayGetIndexed, 1686777561)                    \
   V(_GrowableList, []=, GrowableArraySetIndexed, 327404102)                    \
@@ skipping 525 matching lines @@
   M(ShiftMintOp)                                                               \
   M(UnaryMintOp)                                                               \
   M(CheckArrayBound)                                                           \
   M(Constraint)                                                                \
   M(StringFromCharCode)                                                        \
   M(StringInterpolate)                                                         \
   M(InvokeMathCFunction)                                                       \
   M(GuardField)                                                                \
   M(IfThenElse)                                                                \
   M(BinaryFloat32x4Op)                                                         \
-  M(Float32x4Shuffle)                                                          \
+  M(Simd32x4Shuffle)                                                           \
+  M(Simd32x4ShuffleMix)                                                        \
   M(Simd32x4GetSignMask)                                                       \
   M(Float32x4Constructor)                                                      \
   M(Float32x4Zero)                                                             \
   M(Float32x4Splat)                                                            \
   M(Float32x4Comparison)                                                       \
   M(Float32x4MinMax)                                                           \
   M(Float32x4Scale)                                                            \
   M(Float32x4Sqrt)                                                             \
   M(Float32x4ZeroArg)                                                          \
   M(Float32x4Clamp)                                                            \
   M(Float32x4With)                                                             \
   M(Float32x4ToUint32x4)                                                       \
-  M(Float32x4TwoArgShuffle)                                                    \
   M(MaterializeObject)                                                         \
   M(Uint32x4BoolConstructor)                                                   \
   M(Uint32x4GetFlag)                                                           \
   M(Uint32x4Select)                                                            \
   M(Uint32x4SetFlag)                                                           \
   M(Uint32x4ToFloat32x4)                                                       \
   M(BinaryUint32x4Op)                                                          \
 
 
 #define FORWARD_DECLARATION(type) class type##Instr;
@@ skipping 256 matching lines @@
 
   // Classes that set or read deopt_id_.
   friend class UnboxIntegerInstr;
   friend class UnboxDoubleInstr;
   friend class UnboxFloat32x4Instr;
   friend class UnboxUint32x4Instr;
   friend class BinaryDoubleOpInstr;
   friend class BinaryFloat32x4OpInstr;
   friend class Float32x4ZeroInstr;
   friend class Float32x4SplatInstr;
-  friend class Float32x4ShuffleInstr;
+  friend class Simd32x4ShuffleInstr;
+  friend class Simd32x4ShuffleMixInstr;
   friend class Simd32x4GetSignMaskInstr;
   friend class Float32x4ConstructorInstr;
   friend class Float32x4ComparisonInstr;
   friend class Float32x4MinMaxInstr;
   friend class Float32x4ScaleInstr;
   friend class Float32x4SqrtInstr;
   friend class Float32x4ZeroArgInstr;
   friend class Float32x4ClampInstr;
   friend class Float32x4WithInstr;
   friend class Float32x4ToUint32x4Instr;
-  friend class Float32x4TwoArgShuffleInstr;
   friend class Uint32x4BoolConstructorInstr;
   friend class Uint32x4GetFlagInstr;
   friend class Uint32x4SetFlagInstr;
   friend class Uint32x4SelectInstr;
   friend class Uint32x4ToFloat32x4Instr;
   friend class BinaryUint32x4OpInstr;
   friend class BinaryMintOpInstr;
   friend class BinarySmiOpInstr;
   friend class UnarySmiOpInstr;
   friend class UnaryDoubleOpInstr;
@@ skipping 3997 matching lines @@
 
   virtual bool MayThrow() const { return false; }
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryFloat32x4OpInstr);
 };
 
 
-class Float32x4ShuffleInstr : public TemplateDefinition<1> {
+class Simd32x4ShuffleInstr : public TemplateDefinition<1> {
  public:
-  Float32x4ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
-                        intptr_t mask,
-                        intptr_t deopt_id)
+  Simd32x4ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
+                       intptr_t mask,
+                       intptr_t deopt_id)
       : op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     if ((op_kind_ == MethodRecognizer::kFloat32x4ShuffleX) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleY) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleZ) ||
         (op_kind_ == MethodRecognizer::kFloat32x4ShuffleW)) {
       return kUnboxedDouble;
     }
+    if ((op_kind_ == MethodRecognizer::kUint32x4Shuffle)) {
+      return kUnboxedUint32x4;
+    }
+    ASSERT((op_kind_ == MethodRecognizer::kFloat32x4Shuffle));
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
+    if ((op_kind_ == MethodRecognizer::kFloat32x4ShuffleX) ||
+        (op_kind_ == MethodRecognizer::kFloat32x4ShuffleY) ||
+        (op_kind_ == MethodRecognizer::kFloat32x4ShuffleZ) ||
+        (op_kind_ == MethodRecognizer::kFloat32x4ShuffleW) ||
+        (op_kind_ == MethodRecognizer::kFloat32x4Shuffle)) {
+      return kUnboxedFloat32x4;
+    }
+    ASSERT((op_kind_ == MethodRecognizer::kUint32x4Shuffle));
+    return kUnboxedUint32x4;
+  }
+
+  virtual intptr_t DeoptimizationTarget() const {
+    // Direct access since this instruction cannot deoptimize, and the deopt-id
+    // was inherited from another instruction that could deoptimize.
+    return deopt_id_;
+  }
+
+  DECLARE_INSTRUCTION(Simd32x4Shuffle)
+  virtual CompileType ComputeType() const;
+
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const {
+    return (op_kind() == other->AsSimd32x4Shuffle()->op_kind()) &&
+           (mask() == other->AsSimd32x4Shuffle()->mask());
+  }
+
+  virtual bool MayThrow() const { return false; }
+
+ private:
+  const MethodRecognizer::Kind op_kind_;
+  const intptr_t mask_;
+
+  DISALLOW_COPY_AND_ASSIGN(Simd32x4ShuffleInstr);
+};
+
+
+class Simd32x4ShuffleMixInstr : public TemplateDefinition<2> {
+ public:
+  Simd32x4ShuffleMixInstr(MethodRecognizer::Kind op_kind, Value* xy,
+                           Value* zw, intptr_t mask, intptr_t deopt_id)
+      : op_kind_(op_kind), mask_(mask) {
+    SetInputAt(0, xy);
+    SetInputAt(1, zw);
+    deopt_id_ = deopt_id;
+  }
+
+  Value* xy() const { return inputs_[0]; }
+  Value* zw() const { return inputs_[1]; }
+
+  MethodRecognizer::Kind op_kind() const { return op_kind_; }
+
+  intptr_t mask() const { return mask_; }
+
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
+
+  virtual bool CanDeoptimize() const { return false; }
+
+  virtual Representation representation() const {
+    if (op_kind() == MethodRecognizer::kUint32x4ShuffleMix) {
+      return kUnboxedUint32x4;
+    }
+    ASSERT(op_kind() == MethodRecognizer::kFloat32x4ShuffleMix);
     return kUnboxedFloat32x4;
   }
 
+  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
+    ASSERT((idx == 0) || (idx == 1));
+    if (op_kind() == MethodRecognizer::kUint32x4ShuffleMix) {
+      return kUnboxedUint32x4;
+    }
+    ASSERT(op_kind() == MethodRecognizer::kFloat32x4ShuffleMix);
+    return kUnboxedFloat32x4;
+  }
+
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
-  DECLARE_INSTRUCTION(Float32x4Shuffle)
+  DECLARE_INSTRUCTION(Simd32x4ShuffleMix)
   virtual CompileType ComputeType() const;
 
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
-    return op_kind() == other->AsFloat32x4Shuffle()->op_kind() &&
-           mask() == other->AsFloat32x4Shuffle()->mask();
+    return (op_kind() == other->AsSimd32x4ShuffleMix()->op_kind()) &&
+           (mask() == other->AsSimd32x4ShuffleMix()->mask());
   }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t mask_;
 
-  DISALLOW_COPY_AND_ASSIGN(Float32x4ShuffleInstr);
+  DISALLOW_COPY_AND_ASSIGN(Simd32x4ShuffleMixInstr);
 };
 
 
 class Float32x4ConstructorInstr : public TemplateDefinition<4> {
  public:
   Float32x4ConstructorInstr(Value* value0, Value* value1, Value* value2,
                             Value* value3, intptr_t deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
@@ skipping 682 matching lines @@
 
   virtual bool MayThrow() const { return false; }
 
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd32x4GetSignMaskInstr);
 };
 
 
-class Float32x4TwoArgShuffleInstr : public TemplateDefinition<2> {
- public:
-  Float32x4TwoArgShuffleInstr(MethodRecognizer::Kind op_kind, Value* left,
-                              Value* right, intptr_t deopt_id)
-      : op_kind_(op_kind) {
-    SetInputAt(0, left);
-    SetInputAt(1, right);
-    deopt_id_ = deopt_id;
-  }
-
-  Value* left() const { return inputs_[0]; }
-  Value* right() const { return inputs_[1]; }
-
-  MethodRecognizer::Kind op_kind() const { return op_kind_; }
-
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
-  virtual bool CanDeoptimize() const { return false; }
-
-  virtual Representation representation() const {
-    return kUnboxedFloat32x4;
-  }
-
-  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
-    ASSERT((idx == 0) || (idx == 1));
-    return kUnboxedFloat32x4;
-  }
-
-  virtual intptr_t DeoptimizationTarget() const {
-    // Direct access since this instruction cannot deoptimize, and the deopt-id
-    // was inherited from another instruction that could deoptimize.
-    return deopt_id_;
-  }
-
-  DECLARE_INSTRUCTION(Float32x4TwoArgShuffle)
-  virtual CompileType ComputeType() const;
-
-  virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
-  virtual bool AttributesEqual(Instruction* other) const {
-    return op_kind() == other->AsFloat32x4TwoArgShuffle()->op_kind();
-  }
-
-  virtual bool MayThrow() const { return false; }
-
- private:
-  const MethodRecognizer::Kind op_kind_;
-
-  DISALLOW_COPY_AND_ASSIGN(Float32x4TwoArgShuffleInstr);
-};
-
-
 class Uint32x4SelectInstr : public TemplateDefinition<3> {
  public:
   Uint32x4SelectInstr(Value* mask, Value* trueValue, Value* falseValue,
                       intptr_t deopt_id) {
     SetInputAt(0, mask);
     SetInputAt(1, trueValue);
     SetInputAt(2, falseValue);
     deopt_id_ = deopt_id;
   }
 
@@ skipping 1083 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_