clang-format runtime/lib

runtime/lib/simd128.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/bootstrap_natives.h"
 
 #include "vm/exceptions.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 static void ThrowMaskRangeException(int64_t m) {
   if ((m < 0) || (m > 255)) {
-    Exceptions::ThrowRangeError(
-        "mask", Integer::Handle(Integer::New(m)), 0, 255);
+    Exceptions::ThrowRangeError("mask", Integer::Handle(Integer::New(m)), 0,
+                                255);
   }
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_fromDoubles, 5) {
   ASSERT(TypeArguments::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));
@@ skipping 60 matching lines @@
   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 Float32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_mul, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
-  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other,
-                               arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, 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 Float32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_div, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
@@ skipping 160 matching lines @@
   uint32_t value = mx | (my << 1) | (mz << 2) | (mw << 3);
   return Integer::New(value);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_shuffle, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1));
   int64_t m = mask.AsInt64Value();
   ThrowMaskRangeException(m);
-  float data[4] = { self.x(), self.y(), self.z(), self.w() };
+  float data[4] = {self.x(), self.y(), self.z(), self.w()};
   float _x = data[m & 0x3];
   float _y = data[(m >> 2) & 0x3];
   float _z = data[(m >> 4) & 0x3];
   float _w = data[(m >> 6) & 0x3];
   return Float32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_shuffleMix, 3) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2));
   int64_t m = mask.AsInt64Value();
   ThrowMaskRangeException(m);
-  float data[4] = { self.x(), self.y(), self.z(), self.w() };
-  float other_data[4] = { other.x(), other.y(), other.z(), other.w() };
+  float data[4] = {self.x(), self.y(), self.z(), self.w()};
+  float other_data[4] = {other.x(), other.y(), other.z(), other.w()};
   float _x = data[m & 0x3];
   float _y = data[(m >> 2) & 0x3];
   float _z = other_data[(m >> 4) & 0x3];
   float _w = other_data[(m >> 6) & 0x3];
   return Float32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_setX, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
@@ skipping 34 matching lines @@
   float _x = self.x();
   float _y = self.y();
   float _z = self.z();
   float _w = static_cast<float>(w.value());
   return Float32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_min, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
-  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other,
-                               arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, 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 Float32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_max, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
-  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other,
-                               arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, 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 Float32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float32x4_sqrt, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0));
@@ skipping 140 matching lines @@
   int32_t value = self.w();
   return Integer::New(value);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int32x4_shuffle, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1));
   int64_t m = mask.AsInt64Value();
   ThrowMaskRangeException(m);
-  int32_t data[4] = { self.x(), self.y(), self.z(), self.w() };
+  int32_t data[4] = {self.x(), self.y(), self.z(), self.w()};
   int32_t _x = data[m & 0x3];
   int32_t _y = data[(m >> 2) & 0x3];
   int32_t _z = data[(m >> 4) & 0x3];
   int32_t _w = data[(m >> 6) & 0x3];
   return Int32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int32x4_shuffleMix, 3) {
   GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, zw, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2));
   int64_t m = mask.AsInt64Value();
   ThrowMaskRangeException(m);
-  int32_t data[4] = { self.x(), self.y(), self.z(), self.w() };
-  int32_t zw_data[4] = { zw.x(), zw.y(), zw.z(), zw.w() };
+  int32_t data[4] = {self.x(), self.y(), self.z(), self.w()};
+  int32_t zw_data[4] = {zw.x(), zw.y(), zw.z(), zw.w()};
   int32_t _x = data[m & 0x3];
   int32_t _y = data[(m >> 2) & 0x3];
   int32_t _z = zw_data[(m >> 4) & 0x3];
   int32_t _w = zw_data[(m >> 6) & 0x3];
   return Int32x4::New(_x, _y, _z, _w);
 }
 
 
 DEFINE_NATIVE_ENTRY(Int32x4_setX, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
@@ skipping 113 matching lines @@
   _w = flagW.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0;
   return Int32x4::New(_x, _y, _z, _w);
 }
 
 
 // Used to convert between int32_t and float32 without breaking strict
 // aliasing rules.
 union float32_int32 {
   float f;
   int32_t u;
-  float32_int32(float v) {
-    f = v;
-  }
-  float32_int32(int32_t v) {
-    u = v;
-  }
+  float32_int32(float v) { f = v; }
+  float32_int32(int32_t v) { u = v; }
 };
 
 
 DEFINE_NATIVE_ENTRY(Int32x4_select, 3) {
   GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, tv, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, fv, arguments->NativeArgAt(2));
   int32_t _maskX = self.x();
   int32_t _maskY = self.y();
   int32_t _maskZ = self.z();
@@ skipping 156 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1));
   double _x = self.x();
   double _y = y.value();
   return Float64x2::New(_x, _y);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float64x2_min, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
-  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other,
-                               arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
   double _x = self.x() < other.x() ? self.x() : other.x();
   double _y = self.y() < other.y() ? self.y() : other.y();
   return Float64x2::New(_x, _y);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float64x2_max, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
-  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other,
-                               arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1));
   double _x = self.x() > other.x() ? self.x() : other.x();
   double _y = self.y() > other.y() ? self.y() : other.y();
   return Float64x2::New(_x, _y);
 }
 
 
 DEFINE_NATIVE_ENTRY(Float64x2_sqrt, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0));
   double _x = sqrt(self.x());
   double _y = sqrt(self.y());
   return Float64x2::New(_x, _y);
 }
 
 }  // namespace dart