Simd128Float32, Simd128Mask, and Simd128Float32List additions for dart:scalarlist

runtime/lib/simd128.cc

Index: runtime/lib/simd128.cc
diff --git a/runtime/lib/simd128.cc b/runtime/lib/simd128.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b6e94ad979369283d0e9fbd4c130710b7eeb9b15
--- /dev/null
+++ b/runtime/lib/simd128.cc
@@ -0,0 +1,619 @@
+// 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/bootstrap_natives.h"
+
+#include "vm/exceptions.h"
+#include "vm/native_entry.h"
+#include "vm/object.h"
+#include "vm/symbols.h"
+
+namespace dart {
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_fromDoubles, 5) {
+  ASSERT(AbstractTypeArguments::CheckedHandle(
+      arguments->NativeArgAt(0)).IsNull());
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(2));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(3));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(4));
+  float _x = x.value();
+  float _y = y.value();
+  float _z = z.value();
+  float _w = w.value();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_zero, 1) {
+  ASSERT(AbstractTypeArguments::CheckedHandle(
+      arguments->NativeArgAt(0)).IsNull());
+  return Simd128Float32::New(0.0f, 0.0f, 0.0f, 0.0f);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_add, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, other,
+                               arguments->NativeArgAt(1));
+  float _x = self.x() + other.x();
+  float _y = self.y() + other.y();
+  float _z = self.z() + other.z();
+  float _w = self.w() + other.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_negate, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float _x = -self.x();
+  float _y = -self.y();
+  float _z = -self.z();
+  float _w = -self.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_sub, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, other,
+                               arguments->NativeArgAt(1));
+  float _x = self.x() - other.x();
+  float _y = self.y() - other.y();
+  float _z = self.z() - other.z();
+  float _w = self.w() - other.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_mul, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, other,
+                               arguments->NativeArgAt(1));
+  float _x = self.x() * other.x();
+  float _y = self.y() * other.y();
+  float _z = self.z() * other.z();
+  float _w = self.w() * other.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_div, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, other,
+                               arguments->NativeArgAt(1));
+  float _x = self.x() / other.x();
+  float _y = self.y() / other.y();
+  float _z = self.z() / other.z();
+  float _w = self.w() / other.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_cmplt, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, a, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, b, arguments->NativeArgAt(1));
+  uint32_t _x = a.x() < b.x() ? 0xFFFFFFFF : 0x0;
+  uint32_t _y = a.y() < b.y() ? 0xFFFFFFFF : 0x0;
+  uint32_t _z = a.z() < b.z() ? 0xFFFFFFFF : 0x0;
+  uint32_t _w = a.w() < b.w() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_cmplte, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, a, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, b, arguments->NativeArgAt(1));
+  uint32_t _x = a.x() <= b.x() ? 0xFFFFFFFF : 0x0;
+  uint32_t _y = a.y() <= b.y() ? 0xFFFFFFFF : 0x0;
+  uint32_t _z = a.z() <= b.z() ? 0xFFFFFFFF : 0x0;
+  uint32_t _w = a.w() <= b.w() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_cmpgt, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, a, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, b, arguments->NativeArgAt(1));
+  uint32_t _x = a.x() > b.x() ? 0xFFFFFFFF : 0x0;
+  uint32_t _y = a.y() > b.y() ? 0xFFFFFFFF : 0x0;
+  uint32_t _z = a.z() > b.z() ? 0xFFFFFFFF : 0x0;
+  uint32_t _w = a.w() > b.w() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_cmpgte, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, a, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, b, arguments->NativeArgAt(1));
+  uint32_t _x = a.x() >= b.x() ? 0xFFFFFFFF : 0x0;
+  uint32_t _y = a.y() >= b.y() ? 0xFFFFFFFF : 0x0;
+  uint32_t _z = a.z() >= b.z() ? 0xFFFFFFFF : 0x0;
+  uint32_t _w = a.w() >= b.w() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_cmpequal, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, a, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, b, arguments->NativeArgAt(1));
+  uint32_t _x = a.x() == b.x() ? 0xFFFFFFFF : 0x0;
+  uint32_t _y = a.y() == b.y() ? 0xFFFFFFFF : 0x0;
+  uint32_t _z = a.z() == b.z() ? 0xFFFFFFFF : 0x0;
+  uint32_t _w = a.w() == b.w() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_scale, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, scale, arguments->NativeArgAt(1));
+  float _s = static_cast<float>(scale.value());
+  float _x = self.x() * _s;
+  float _y = self.y() * _s;
+  float _z = self.z() * _s;
+  float _w = self.w() * _s;
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_abs, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float _x = fabsf(self.x());
+  float _y = fabsf(self.y());
+  float _z = fabsf(self.z());
+  float _w = fabsf(self.w());
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_clamp, 3) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, lo, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, hi, arguments->NativeArgAt(2));
+  float _x = self.x() > lo.x() ? self.x() : lo.x();
+  float _y = self.y() > lo.y() ? self.y() : lo.y();
+  float _z = self.z() > lo.z() ? self.z() : lo.z();
+  float _w = self.w() > lo.w() ? self.w() : lo.w();
+  _x = _x > hi.x() ? hi.x() : _x;
+  _y = _y > hi.y() ? hi.y() : _y;
+  _z = _z > hi.z() ? hi.z() : _z;
+  _w = _w > hi.w() ? hi.w() : _w;
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getX, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  double value = static_cast<double>(self.x());
+  return Double::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getY, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  double value = static_cast<double>(self.y());
+  return Double::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getZ, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  double value = static_cast<double>(self.z());
+  return Double::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getW, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  double value = static_cast<double>(self.w());
+  return Double::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getXXXX, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float value = self.x();
+  return Simd128Float32::New(value, value, value, value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getYYYY, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float value = self.y();
+  return Simd128Float32::New(value, value, value, value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getZZZZ, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float value = self.z();
+  return Simd128Float32::New(value, value, value, value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_getWWWW, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float value = self.w();
+  return Simd128Float32::New(value, value, value, value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_setX, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1));
+  float _x = static_cast<float>(x.value());
+  float _y = self.y();
+  float _z = self.z();
+  float _w = self.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_setY, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1));
+  float _x = self.x();
+  float _y = static_cast<float>(y.value());
+  float _z = self.z();
+  float _w = self.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_setZ, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(1));
+  float _x = self.x();
+  float _y = self.y();
+  float _z = static_cast<float>(z.value());
+  float _w = self.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_setW, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(1));
+  float _x = self.x();
+  float _y = self.y();
+  float _z = self.z();
+  float _w = static_cast<float>(w.value());
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_min, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, other,
+                               arguments->NativeArgAt(1));
+  float _x = self.x() < other.x() ? self.x() : other.x();
+  float _y = self.y() < other.y() ? self.y() : other.y();
+  float _z = self.z() < other.z() ? self.z() : other.z();
+  float _w = self.w() < other.w() ? self.w() : other.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_max, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, other,
+                               arguments->NativeArgAt(1));
+  float _x = self.x() > other.x() ? self.x() : other.x();
+  float _y = self.y() > other.y() ? self.y() : other.y();
+  float _z = self.z() > other.z() ? self.z() : other.z();
+  float _w = self.w() > other.w() ? self.w() : other.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_sqrt, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float _x = sqrtf(self.x());
+  float _y = sqrtf(self.y());
+  float _z = sqrtf(self.z());
+  float _w = sqrtf(self.w());
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_reciprocal, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float _x = 1.0f / self.x();
+  float _y = 1.0f / self.y();
+  float _z = 1.0f / self.z();
+  float _w = 1.0f / self.w();
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_reciprocalSqrt, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, self, arguments->NativeArgAt(0));
+  float _x = sqrtf(1.0f / self.x());
+  float _y = sqrtf(1.0f / self.y());
+  float _z = sqrtf(1.0f / self.z());
+  float _w = sqrtf(1.0f / self.w());
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Float32_toSimd128Mask, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, v, arguments->NativeArgAt(0));
+  float _fx = v.x();
+  float _fy = v.y();
+  float _fz = v.z();
+  float _fw = v.w();
+  uint32_t _x = *reinterpret_cast<uint32_t*>(&_fx);
+  uint32_t _y = *reinterpret_cast<uint32_t*>(&_fy);
+  uint32_t _z = *reinterpret_cast<uint32_t*>(&_fz);
+  uint32_t _w = *reinterpret_cast<uint32_t*>(&_fw);
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_fromInts, 5) {
+  ASSERT(AbstractTypeArguments::CheckedHandle(
+      arguments->NativeArgAt(0)).IsNull());
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(2));
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(3));
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(4));
+  uint32_t _x = static_cast<uint32_t>(x.AsInt64Value() & 0xFFFFFFFF);
+  uint32_t _y = static_cast<uint32_t>(y.AsInt64Value() & 0xFFFFFFFF);
+  uint32_t _z = static_cast<uint32_t>(z.AsInt64Value() & 0xFFFFFFFF);
+  uint32_t _w = static_cast<uint32_t>(w.AsInt64Value() & 0xFFFFFFFF);
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_fromBools, 5) {
+  ASSERT(AbstractTypeArguments::CheckedHandle(
+      arguments->NativeArgAt(0)).IsNull());
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, x, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, y, arguments->NativeArgAt(2));
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, z, arguments->NativeArgAt(3));
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, w, arguments->NativeArgAt(4));
+  uint32_t _x = x.value() ? 0xFFFFFFFF : 0x0;
+  uint32_t _y = y.value() ? 0xFFFFFFFF : 0x0;
+  uint32_t _z = z.value() ? 0xFFFFFFFF : 0x0;
+  uint32_t _w = w.value() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_or, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, other, arguments->NativeArgAt(1));
+  uint32_t _x = self.x() | other.x();
+  uint32_t _y = self.y() | other.y();
+  uint32_t _z = self.z() | other.z();
+  uint32_t _w = self.w() | other.w();
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_and, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, other, arguments->NativeArgAt(1));
+  uint32_t _x = self.x() & other.x();
+  uint32_t _y = self.y() & other.y();
+  uint32_t _z = self.z() & other.z();
+  uint32_t _w = self.w() & other.w();
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_xor, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, other, arguments->NativeArgAt(1));
+  uint32_t _x = self.x() ^ other.x();
+  uint32_t _y = self.y() ^ other.y();
+  uint32_t _z = self.z() ^ other.z();
+  uint32_t _w = self.w() ^ other.w();
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getX, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.x();
+  return Integer::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getY, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.y();
+  return Integer::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getZ, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.z();
+  return Integer::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getW, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.w();
+  return Integer::New(value);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setX, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(1));
+  uint32_t _x = static_cast<uint32_t>(x.AsInt64Value() & 0xFFFFFFFF);
+  uint32_t _y = self.y();
+  uint32_t _z = self.z();
+  uint32_t _w = self.w();
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setY, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(1));
+  uint32_t _x = self.x();
+  uint32_t _y = static_cast<uint32_t>(y.AsInt64Value() & 0xFFFFFFFF);
+  uint32_t _z = self.z();
+  uint32_t _w = self.w();
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setZ, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(1));
+  uint32_t _x = self.x();
+  uint32_t _y = self.y();
+  uint32_t _z = static_cast<uint32_t>(z.AsInt64Value() & 0xFFFFFFFF);
+  uint32_t _w = self.w();
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setW, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(1));
+  uint32_t _x = self.x();
+  uint32_t _y = self.y();
+  uint32_t _z = self.z();
+  uint32_t _w = static_cast<uint32_t>(w.AsInt64Value() & 0xFFFFFFFF);
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getFlagX, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.x();
+  return value != 0 ? Bool::True().raw() : Bool::False().raw();
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getFlagY, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.y();
+  return value != 0 ? Bool::True().raw() : Bool::False().raw();
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getFlagZ, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.z();
+  return value != 0 ? Bool::True().raw() : Bool::False().raw();
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_getFlagW, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  uint32_t value = self.w();
+  return value != 0 ? Bool::True().raw() : Bool::False().raw();
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setFlagX, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagX, arguments->NativeArgAt(1));
+  uint32_t _x = self.x();
+  uint32_t _y = self.y();
+  uint32_t _z = self.z();
+  uint32_t _w = self.w();
+  _x = flagX.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setFlagY, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagY, arguments->NativeArgAt(1));
+  uint32_t _x = self.x();
+  uint32_t _y = self.y();
+  uint32_t _z = self.z();
+  uint32_t _w = self.w();
+  _y = flagY.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setFlagZ, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagZ, arguments->NativeArgAt(1));
+  uint32_t _x = self.x();
+  uint32_t _y = self.y();
+  uint32_t _z = self.z();
+  uint32_t _w = self.w();
+  _z = flagZ.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_setFlagW, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagW, arguments->NativeArgAt(1));
+  uint32_t _x = self.x();
+  uint32_t _y = self.y();
+  uint32_t _z = self.z();
+  uint32_t _w = self.w();
+  _w = flagW.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0;
+  return Simd128Mask::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_select, 3) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, self, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, tv, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Float32, fv, arguments->NativeArgAt(2));
+  uint32_t _maskX = self.x();
+  uint32_t _maskY = self.y();
+  uint32_t _maskZ = self.z();
+  uint32_t _maskW = self.w();
+  // Extract floats and interpret them as masks.
+  float _tx = tv.x();
+  float _ty = tv.y();
+  float _tz = tv.z();
+  float _tw = tv.w();
+  float _fx = fv.x();
+  float _fy = fv.y();
+  float _fz = fv.z();
+  float _fw = fv.w();
+  uint32_t _tvx = *reinterpret_cast<uint32_t*>(&_tx);
+  uint32_t _tvy = *reinterpret_cast<uint32_t*>(&_ty);
+  uint32_t _tvz = *reinterpret_cast<uint32_t*>(&_tz);
+  uint32_t _tvw = *reinterpret_cast<uint32_t*>(&_tw);
+  uint32_t _fvx = *reinterpret_cast<uint32_t*>(&_fx);
+  uint32_t _fvy = *reinterpret_cast<uint32_t*>(&_fy);
+  uint32_t _fvz = *reinterpret_cast<uint32_t*>(&_fz);
+  uint32_t _fvw = *reinterpret_cast<uint32_t*>(&_fw);
+  // Perform select.
+  uint32_t _tempX = (_maskX & _tvx) | (~_maskX & _fvx);
+  uint32_t _tempY = (_maskY & _tvy) | (~_maskY & _fvy);
+  uint32_t _tempZ = (_maskZ & _tvz) | (~_maskZ & _fvz);
+  uint32_t _tempW = (_maskW & _tvw) | (~_maskW & _fvw);
+  // Interpret the result as floats.
+  float _x = *reinterpret_cast<float*>(&_tempX);
+  float _y = *reinterpret_cast<float*>(&_tempY);
+  float _z = *reinterpret_cast<float*>(&_tempZ);
+  float _w = *reinterpret_cast<float*>(&_tempW);
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+DEFINE_NATIVE_ENTRY(Simd128Mask_toSimd128Float32, 1) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Simd128Mask, v, arguments->NativeArgAt(0));
+  uint32_t _ix = v.x();
+  uint32_t _iy = v.y();
+  uint32_t _iz = v.z();
+  uint32_t _iw = v.w();
+  float _x = *reinterpret_cast<float*>(&_ix);
+  float _y = *reinterpret_cast<float*>(&_iy);
+  float _z = *reinterpret_cast<float*>(&_iz);
+  float _w = *reinterpret_cast<float*>(&_iw);
+  return Simd128Float32::New(_x, _y, _z, _w);
+}
+
+
+}  // namespace dart