OLD | NEW |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/bootstrap_natives.h" | 5 #include "vm/bootstrap_natives.h" |
6 | 6 |
7 #include "vm/exceptions.h" | 7 #include "vm/exceptions.h" |
8 #include "vm/native_entry.h" | 8 #include "vm/native_entry.h" |
9 #include "vm/object.h" | 9 #include "vm/object.h" |
10 #include "vm/symbols.h" | 10 #include "vm/symbols.h" |
11 | 11 |
12 namespace dart { | 12 namespace dart { |
13 | 13 |
14 static void ThrowMaskRangeException(int64_t m) { | 14 static void ThrowMaskRangeException(int64_t m) { |
15 if ((m < 0) || (m > 255)) { | 15 if ((m < 0) || (m > 255)) { |
16 Exceptions::ThrowRangeError("mask", Integer::Handle(Integer::New(m)), 0, | 16 Exceptions::ThrowRangeError("mask", Integer::Handle(Integer::New(m)), 0, |
17 255); | 17 255); |
18 } | 18 } |
19 } | 19 } |
20 | 20 |
21 | |
22 DEFINE_NATIVE_ENTRY(Float32x4_fromDoubles, 5) { | 21 DEFINE_NATIVE_ENTRY(Float32x4_fromDoubles, 5) { |
23 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 22 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
24 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); | 23 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); |
25 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(2)); | 24 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(2)); |
26 GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(3)); | 25 GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(3)); |
27 GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(4)); | 26 GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(4)); |
28 float _x = static_cast<float>(x.value()); | 27 float _x = static_cast<float>(x.value()); |
29 float _y = static_cast<float>(y.value()); | 28 float _y = static_cast<float>(y.value()); |
30 float _z = static_cast<float>(z.value()); | 29 float _z = static_cast<float>(z.value()); |
31 float _w = static_cast<float>(w.value()); | 30 float _w = static_cast<float>(w.value()); |
32 return Float32x4::New(_x, _y, _z, _w); | 31 return Float32x4::New(_x, _y, _z, _w); |
33 } | 32 } |
34 | 33 |
35 | |
36 DEFINE_NATIVE_ENTRY(Float32x4_splat, 2) { | 34 DEFINE_NATIVE_ENTRY(Float32x4_splat, 2) { |
37 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 35 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
38 GET_NON_NULL_NATIVE_ARGUMENT(Double, v, arguments->NativeArgAt(1)); | 36 GET_NON_NULL_NATIVE_ARGUMENT(Double, v, arguments->NativeArgAt(1)); |
39 float _v = v.value(); | 37 float _v = v.value(); |
40 return Float32x4::New(_v, _v, _v, _v); | 38 return Float32x4::New(_v, _v, _v, _v); |
41 } | 39 } |
42 | 40 |
43 | |
44 DEFINE_NATIVE_ENTRY(Float32x4_zero, 1) { | 41 DEFINE_NATIVE_ENTRY(Float32x4_zero, 1) { |
45 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 42 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
46 return Float32x4::New(0.0f, 0.0f, 0.0f, 0.0f); | 43 return Float32x4::New(0.0f, 0.0f, 0.0f, 0.0f); |
47 } | 44 } |
48 | 45 |
49 | |
50 DEFINE_NATIVE_ENTRY(Float32x4_fromInt32x4Bits, 2) { | 46 DEFINE_NATIVE_ENTRY(Float32x4_fromInt32x4Bits, 2) { |
51 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, v, arguments->NativeArgAt(1)); | 47 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, v, arguments->NativeArgAt(1)); |
52 return Float32x4::New(v.value()); | 48 return Float32x4::New(v.value()); |
53 } | 49 } |
54 | 50 |
55 | |
56 DEFINE_NATIVE_ENTRY(Float32x4_fromFloat64x2, 2) { | 51 DEFINE_NATIVE_ENTRY(Float32x4_fromFloat64x2, 2) { |
57 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, v, arguments->NativeArgAt(1)); | 52 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, v, arguments->NativeArgAt(1)); |
58 float _x = static_cast<float>(v.x()); | 53 float _x = static_cast<float>(v.x()); |
59 float _y = static_cast<float>(v.y()); | 54 float _y = static_cast<float>(v.y()); |
60 return Float32x4::New(_x, _y, 0.0f, 0.0f); | 55 return Float32x4::New(_x, _y, 0.0f, 0.0f); |
61 } | 56 } |
62 | 57 |
63 | |
64 DEFINE_NATIVE_ENTRY(Float32x4_add, 2) { | 58 DEFINE_NATIVE_ENTRY(Float32x4_add, 2) { |
65 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 59 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
66 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); | 60 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); |
67 float _x = self.x() + other.x(); | 61 float _x = self.x() + other.x(); |
68 float _y = self.y() + other.y(); | 62 float _y = self.y() + other.y(); |
69 float _z = self.z() + other.z(); | 63 float _z = self.z() + other.z(); |
70 float _w = self.w() + other.w(); | 64 float _w = self.w() + other.w(); |
71 return Float32x4::New(_x, _y, _z, _w); | 65 return Float32x4::New(_x, _y, _z, _w); |
72 } | 66 } |
73 | 67 |
74 | |
75 DEFINE_NATIVE_ENTRY(Float32x4_negate, 1) { | 68 DEFINE_NATIVE_ENTRY(Float32x4_negate, 1) { |
76 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 69 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
77 float _x = -self.x(); | 70 float _x = -self.x(); |
78 float _y = -self.y(); | 71 float _y = -self.y(); |
79 float _z = -self.z(); | 72 float _z = -self.z(); |
80 float _w = -self.w(); | 73 float _w = -self.w(); |
81 return Float32x4::New(_x, _y, _z, _w); | 74 return Float32x4::New(_x, _y, _z, _w); |
82 } | 75 } |
83 | 76 |
84 | |
85 DEFINE_NATIVE_ENTRY(Float32x4_sub, 2) { | 77 DEFINE_NATIVE_ENTRY(Float32x4_sub, 2) { |
86 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 78 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
87 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); | 79 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); |
88 float _x = self.x() - other.x(); | 80 float _x = self.x() - other.x(); |
89 float _y = self.y() - other.y(); | 81 float _y = self.y() - other.y(); |
90 float _z = self.z() - other.z(); | 82 float _z = self.z() - other.z(); |
91 float _w = self.w() - other.w(); | 83 float _w = self.w() - other.w(); |
92 return Float32x4::New(_x, _y, _z, _w); | 84 return Float32x4::New(_x, _y, _z, _w); |
93 } | 85 } |
94 | 86 |
95 | |
96 DEFINE_NATIVE_ENTRY(Float32x4_mul, 2) { | 87 DEFINE_NATIVE_ENTRY(Float32x4_mul, 2) { |
97 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 88 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
98 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); | 89 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); |
99 float _x = self.x() * other.x(); | 90 float _x = self.x() * other.x(); |
100 float _y = self.y() * other.y(); | 91 float _y = self.y() * other.y(); |
101 float _z = self.z() * other.z(); | 92 float _z = self.z() * other.z(); |
102 float _w = self.w() * other.w(); | 93 float _w = self.w() * other.w(); |
103 return Float32x4::New(_x, _y, _z, _w); | 94 return Float32x4::New(_x, _y, _z, _w); |
104 } | 95 } |
105 | 96 |
106 | |
107 DEFINE_NATIVE_ENTRY(Float32x4_div, 2) { | 97 DEFINE_NATIVE_ENTRY(Float32x4_div, 2) { |
108 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 98 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
109 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); | 99 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); |
110 float _x = self.x() / other.x(); | 100 float _x = self.x() / other.x(); |
111 float _y = self.y() / other.y(); | 101 float _y = self.y() / other.y(); |
112 float _z = self.z() / other.z(); | 102 float _z = self.z() / other.z(); |
113 float _w = self.w() / other.w(); | 103 float _w = self.w() / other.w(); |
114 return Float32x4::New(_x, _y, _z, _w); | 104 return Float32x4::New(_x, _y, _z, _w); |
115 } | 105 } |
116 | 106 |
117 | |
118 DEFINE_NATIVE_ENTRY(Float32x4_cmplt, 2) { | 107 DEFINE_NATIVE_ENTRY(Float32x4_cmplt, 2) { |
119 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); | 108 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); |
120 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); | 109 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); |
121 uint32_t _x = a.x() < b.x() ? 0xFFFFFFFF : 0x0; | 110 uint32_t _x = a.x() < b.x() ? 0xFFFFFFFF : 0x0; |
122 uint32_t _y = a.y() < b.y() ? 0xFFFFFFFF : 0x0; | 111 uint32_t _y = a.y() < b.y() ? 0xFFFFFFFF : 0x0; |
123 uint32_t _z = a.z() < b.z() ? 0xFFFFFFFF : 0x0; | 112 uint32_t _z = a.z() < b.z() ? 0xFFFFFFFF : 0x0; |
124 uint32_t _w = a.w() < b.w() ? 0xFFFFFFFF : 0x0; | 113 uint32_t _w = a.w() < b.w() ? 0xFFFFFFFF : 0x0; |
125 return Int32x4::New(_x, _y, _z, _w); | 114 return Int32x4::New(_x, _y, _z, _w); |
126 } | 115 } |
127 | 116 |
128 | |
129 DEFINE_NATIVE_ENTRY(Float32x4_cmplte, 2) { | 117 DEFINE_NATIVE_ENTRY(Float32x4_cmplte, 2) { |
130 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); | 118 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); |
131 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); | 119 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); |
132 uint32_t _x = a.x() <= b.x() ? 0xFFFFFFFF : 0x0; | 120 uint32_t _x = a.x() <= b.x() ? 0xFFFFFFFF : 0x0; |
133 uint32_t _y = a.y() <= b.y() ? 0xFFFFFFFF : 0x0; | 121 uint32_t _y = a.y() <= b.y() ? 0xFFFFFFFF : 0x0; |
134 uint32_t _z = a.z() <= b.z() ? 0xFFFFFFFF : 0x0; | 122 uint32_t _z = a.z() <= b.z() ? 0xFFFFFFFF : 0x0; |
135 uint32_t _w = a.w() <= b.w() ? 0xFFFFFFFF : 0x0; | 123 uint32_t _w = a.w() <= b.w() ? 0xFFFFFFFF : 0x0; |
136 return Int32x4::New(_x, _y, _z, _w); | 124 return Int32x4::New(_x, _y, _z, _w); |
137 } | 125 } |
138 | 126 |
139 | |
140 DEFINE_NATIVE_ENTRY(Float32x4_cmpgt, 2) { | 127 DEFINE_NATIVE_ENTRY(Float32x4_cmpgt, 2) { |
141 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); | 128 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); |
142 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); | 129 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); |
143 uint32_t _x = a.x() > b.x() ? 0xFFFFFFFF : 0x0; | 130 uint32_t _x = a.x() > b.x() ? 0xFFFFFFFF : 0x0; |
144 uint32_t _y = a.y() > b.y() ? 0xFFFFFFFF : 0x0; | 131 uint32_t _y = a.y() > b.y() ? 0xFFFFFFFF : 0x0; |
145 uint32_t _z = a.z() > b.z() ? 0xFFFFFFFF : 0x0; | 132 uint32_t _z = a.z() > b.z() ? 0xFFFFFFFF : 0x0; |
146 uint32_t _w = a.w() > b.w() ? 0xFFFFFFFF : 0x0; | 133 uint32_t _w = a.w() > b.w() ? 0xFFFFFFFF : 0x0; |
147 return Int32x4::New(_x, _y, _z, _w); | 134 return Int32x4::New(_x, _y, _z, _w); |
148 } | 135 } |
149 | 136 |
150 | |
151 DEFINE_NATIVE_ENTRY(Float32x4_cmpgte, 2) { | 137 DEFINE_NATIVE_ENTRY(Float32x4_cmpgte, 2) { |
152 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); | 138 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); |
153 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); | 139 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); |
154 uint32_t _x = a.x() >= b.x() ? 0xFFFFFFFF : 0x0; | 140 uint32_t _x = a.x() >= b.x() ? 0xFFFFFFFF : 0x0; |
155 uint32_t _y = a.y() >= b.y() ? 0xFFFFFFFF : 0x0; | 141 uint32_t _y = a.y() >= b.y() ? 0xFFFFFFFF : 0x0; |
156 uint32_t _z = a.z() >= b.z() ? 0xFFFFFFFF : 0x0; | 142 uint32_t _z = a.z() >= b.z() ? 0xFFFFFFFF : 0x0; |
157 uint32_t _w = a.w() >= b.w() ? 0xFFFFFFFF : 0x0; | 143 uint32_t _w = a.w() >= b.w() ? 0xFFFFFFFF : 0x0; |
158 return Int32x4::New(_x, _y, _z, _w); | 144 return Int32x4::New(_x, _y, _z, _w); |
159 } | 145 } |
160 | 146 |
161 | |
162 DEFINE_NATIVE_ENTRY(Float32x4_cmpequal, 2) { | 147 DEFINE_NATIVE_ENTRY(Float32x4_cmpequal, 2) { |
163 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); | 148 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); |
164 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); | 149 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); |
165 uint32_t _x = a.x() == b.x() ? 0xFFFFFFFF : 0x0; | 150 uint32_t _x = a.x() == b.x() ? 0xFFFFFFFF : 0x0; |
166 uint32_t _y = a.y() == b.y() ? 0xFFFFFFFF : 0x0; | 151 uint32_t _y = a.y() == b.y() ? 0xFFFFFFFF : 0x0; |
167 uint32_t _z = a.z() == b.z() ? 0xFFFFFFFF : 0x0; | 152 uint32_t _z = a.z() == b.z() ? 0xFFFFFFFF : 0x0; |
168 uint32_t _w = a.w() == b.w() ? 0xFFFFFFFF : 0x0; | 153 uint32_t _w = a.w() == b.w() ? 0xFFFFFFFF : 0x0; |
169 return Int32x4::New(_x, _y, _z, _w); | 154 return Int32x4::New(_x, _y, _z, _w); |
170 } | 155 } |
171 | 156 |
172 | |
173 DEFINE_NATIVE_ENTRY(Float32x4_cmpnequal, 2) { | 157 DEFINE_NATIVE_ENTRY(Float32x4_cmpnequal, 2) { |
174 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); | 158 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, a, arguments->NativeArgAt(0)); |
175 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); | 159 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, b, arguments->NativeArgAt(1)); |
176 uint32_t _x = a.x() != b.x() ? 0xFFFFFFFF : 0x0; | 160 uint32_t _x = a.x() != b.x() ? 0xFFFFFFFF : 0x0; |
177 uint32_t _y = a.y() != b.y() ? 0xFFFFFFFF : 0x0; | 161 uint32_t _y = a.y() != b.y() ? 0xFFFFFFFF : 0x0; |
178 uint32_t _z = a.z() != b.z() ? 0xFFFFFFFF : 0x0; | 162 uint32_t _z = a.z() != b.z() ? 0xFFFFFFFF : 0x0; |
179 uint32_t _w = a.w() != b.w() ? 0xFFFFFFFF : 0x0; | 163 uint32_t _w = a.w() != b.w() ? 0xFFFFFFFF : 0x0; |
180 return Int32x4::New(_x, _y, _z, _w); | 164 return Int32x4::New(_x, _y, _z, _w); |
181 } | 165 } |
182 | 166 |
183 | |
184 DEFINE_NATIVE_ENTRY(Float32x4_scale, 2) { | 167 DEFINE_NATIVE_ENTRY(Float32x4_scale, 2) { |
185 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 168 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
186 GET_NON_NULL_NATIVE_ARGUMENT(Double, scale, arguments->NativeArgAt(1)); | 169 GET_NON_NULL_NATIVE_ARGUMENT(Double, scale, arguments->NativeArgAt(1)); |
187 float _s = static_cast<float>(scale.value()); | 170 float _s = static_cast<float>(scale.value()); |
188 float _x = self.x() * _s; | 171 float _x = self.x() * _s; |
189 float _y = self.y() * _s; | 172 float _y = self.y() * _s; |
190 float _z = self.z() * _s; | 173 float _z = self.z() * _s; |
191 float _w = self.w() * _s; | 174 float _w = self.w() * _s; |
192 return Float32x4::New(_x, _y, _z, _w); | 175 return Float32x4::New(_x, _y, _z, _w); |
193 } | 176 } |
194 | 177 |
195 | |
196 DEFINE_NATIVE_ENTRY(Float32x4_abs, 1) { | 178 DEFINE_NATIVE_ENTRY(Float32x4_abs, 1) { |
197 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 179 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
198 float _x = fabsf(self.x()); | 180 float _x = fabsf(self.x()); |
199 float _y = fabsf(self.y()); | 181 float _y = fabsf(self.y()); |
200 float _z = fabsf(self.z()); | 182 float _z = fabsf(self.z()); |
201 float _w = fabsf(self.w()); | 183 float _w = fabsf(self.w()); |
202 return Float32x4::New(_x, _y, _z, _w); | 184 return Float32x4::New(_x, _y, _z, _w); |
203 } | 185 } |
204 | 186 |
205 | |
206 DEFINE_NATIVE_ENTRY(Float32x4_clamp, 3) { | 187 DEFINE_NATIVE_ENTRY(Float32x4_clamp, 3) { |
207 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 188 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
208 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, lo, arguments->NativeArgAt(1)); | 189 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, lo, arguments->NativeArgAt(1)); |
209 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, hi, arguments->NativeArgAt(2)); | 190 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, hi, arguments->NativeArgAt(2)); |
210 // The order of the clamping must match the order of the optimized code: | 191 // The order of the clamping must match the order of the optimized code: |
211 // MAX(MIN(self, hi), lo). | 192 // MAX(MIN(self, hi), lo). |
212 float _x = self.x() < hi.x() ? self.x() : hi.x(); | 193 float _x = self.x() < hi.x() ? self.x() : hi.x(); |
213 float _y = self.y() < hi.y() ? self.y() : hi.y(); | 194 float _y = self.y() < hi.y() ? self.y() : hi.y(); |
214 float _z = self.z() < hi.z() ? self.z() : hi.z(); | 195 float _z = self.z() < hi.z() ? self.z() : hi.z(); |
215 float _w = self.w() < hi.w() ? self.w() : hi.w(); | 196 float _w = self.w() < hi.w() ? self.w() : hi.w(); |
216 _x = _x < lo.x() ? lo.x() : _x; | 197 _x = _x < lo.x() ? lo.x() : _x; |
217 _y = _y < lo.y() ? lo.y() : _y; | 198 _y = _y < lo.y() ? lo.y() : _y; |
218 _z = _z < lo.z() ? lo.z() : _z; | 199 _z = _z < lo.z() ? lo.z() : _z; |
219 _w = _w < lo.w() ? lo.w() : _w; | 200 _w = _w < lo.w() ? lo.w() : _w; |
220 return Float32x4::New(_x, _y, _z, _w); | 201 return Float32x4::New(_x, _y, _z, _w); |
221 } | 202 } |
222 | 203 |
223 | |
224 DEFINE_NATIVE_ENTRY(Float32x4_getX, 1) { | 204 DEFINE_NATIVE_ENTRY(Float32x4_getX, 1) { |
225 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 205 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
226 double value = static_cast<double>(self.x()); | 206 double value = static_cast<double>(self.x()); |
227 return Double::New(value); | 207 return Double::New(value); |
228 } | 208 } |
229 | 209 |
230 | |
231 DEFINE_NATIVE_ENTRY(Float32x4_getY, 1) { | 210 DEFINE_NATIVE_ENTRY(Float32x4_getY, 1) { |
232 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 211 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
233 double value = static_cast<double>(self.y()); | 212 double value = static_cast<double>(self.y()); |
234 return Double::New(value); | 213 return Double::New(value); |
235 } | 214 } |
236 | 215 |
237 | |
238 DEFINE_NATIVE_ENTRY(Float32x4_getZ, 1) { | 216 DEFINE_NATIVE_ENTRY(Float32x4_getZ, 1) { |
239 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 217 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
240 double value = static_cast<double>(self.z()); | 218 double value = static_cast<double>(self.z()); |
241 return Double::New(value); | 219 return Double::New(value); |
242 } | 220 } |
243 | 221 |
244 | |
245 DEFINE_NATIVE_ENTRY(Float32x4_getW, 1) { | 222 DEFINE_NATIVE_ENTRY(Float32x4_getW, 1) { |
246 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 223 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
247 double value = static_cast<double>(self.w()); | 224 double value = static_cast<double>(self.w()); |
248 return Double::New(value); | 225 return Double::New(value); |
249 } | 226 } |
250 | 227 |
251 | |
252 DEFINE_NATIVE_ENTRY(Float32x4_getSignMask, 1) { | 228 DEFINE_NATIVE_ENTRY(Float32x4_getSignMask, 1) { |
253 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 229 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
254 uint32_t mx = (bit_cast<uint32_t>(self.x()) & 0x80000000) >> 31; | 230 uint32_t mx = (bit_cast<uint32_t>(self.x()) & 0x80000000) >> 31; |
255 uint32_t my = (bit_cast<uint32_t>(self.y()) & 0x80000000) >> 31; | 231 uint32_t my = (bit_cast<uint32_t>(self.y()) & 0x80000000) >> 31; |
256 uint32_t mz = (bit_cast<uint32_t>(self.z()) & 0x80000000) >> 31; | 232 uint32_t mz = (bit_cast<uint32_t>(self.z()) & 0x80000000) >> 31; |
257 uint32_t mw = (bit_cast<uint32_t>(self.w()) & 0x80000000) >> 31; | 233 uint32_t mw = (bit_cast<uint32_t>(self.w()) & 0x80000000) >> 31; |
258 uint32_t value = mx | (my << 1) | (mz << 2) | (mw << 3); | 234 uint32_t value = mx | (my << 1) | (mz << 2) | (mw << 3); |
259 return Integer::New(value); | 235 return Integer::New(value); |
260 } | 236 } |
261 | 237 |
262 | |
263 DEFINE_NATIVE_ENTRY(Int32x4_getSignMask, 1) { | 238 DEFINE_NATIVE_ENTRY(Int32x4_getSignMask, 1) { |
264 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 239 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
265 uint32_t mx = (self.x() & 0x80000000) >> 31; | 240 uint32_t mx = (self.x() & 0x80000000) >> 31; |
266 uint32_t my = (self.y() & 0x80000000) >> 31; | 241 uint32_t my = (self.y() & 0x80000000) >> 31; |
267 uint32_t mz = (self.z() & 0x80000000) >> 31; | 242 uint32_t mz = (self.z() & 0x80000000) >> 31; |
268 uint32_t mw = (self.w() & 0x80000000) >> 31; | 243 uint32_t mw = (self.w() & 0x80000000) >> 31; |
269 uint32_t value = mx | (my << 1) | (mz << 2) | (mw << 3); | 244 uint32_t value = mx | (my << 1) | (mz << 2) | (mw << 3); |
270 return Integer::New(value); | 245 return Integer::New(value); |
271 } | 246 } |
272 | 247 |
273 | |
274 DEFINE_NATIVE_ENTRY(Float32x4_shuffle, 2) { | 248 DEFINE_NATIVE_ENTRY(Float32x4_shuffle, 2) { |
275 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 249 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
276 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1)); | 250 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1)); |
277 int64_t m = mask.AsInt64Value(); | 251 int64_t m = mask.AsInt64Value(); |
278 ThrowMaskRangeException(m); | 252 ThrowMaskRangeException(m); |
279 float data[4] = {self.x(), self.y(), self.z(), self.w()}; | 253 float data[4] = {self.x(), self.y(), self.z(), self.w()}; |
280 float _x = data[m & 0x3]; | 254 float _x = data[m & 0x3]; |
281 float _y = data[(m >> 2) & 0x3]; | 255 float _y = data[(m >> 2) & 0x3]; |
282 float _z = data[(m >> 4) & 0x3]; | 256 float _z = data[(m >> 4) & 0x3]; |
283 float _w = data[(m >> 6) & 0x3]; | 257 float _w = data[(m >> 6) & 0x3]; |
284 return Float32x4::New(_x, _y, _z, _w); | 258 return Float32x4::New(_x, _y, _z, _w); |
285 } | 259 } |
286 | 260 |
287 | |
288 DEFINE_NATIVE_ENTRY(Float32x4_shuffleMix, 3) { | 261 DEFINE_NATIVE_ENTRY(Float32x4_shuffleMix, 3) { |
289 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 262 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
290 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); | 263 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); |
291 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2)); | 264 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2)); |
292 int64_t m = mask.AsInt64Value(); | 265 int64_t m = mask.AsInt64Value(); |
293 ThrowMaskRangeException(m); | 266 ThrowMaskRangeException(m); |
294 float data[4] = {self.x(), self.y(), self.z(), self.w()}; | 267 float data[4] = {self.x(), self.y(), self.z(), self.w()}; |
295 float other_data[4] = {other.x(), other.y(), other.z(), other.w()}; | 268 float other_data[4] = {other.x(), other.y(), other.z(), other.w()}; |
296 float _x = data[m & 0x3]; | 269 float _x = data[m & 0x3]; |
297 float _y = data[(m >> 2) & 0x3]; | 270 float _y = data[(m >> 2) & 0x3]; |
298 float _z = other_data[(m >> 4) & 0x3]; | 271 float _z = other_data[(m >> 4) & 0x3]; |
299 float _w = other_data[(m >> 6) & 0x3]; | 272 float _w = other_data[(m >> 6) & 0x3]; |
300 return Float32x4::New(_x, _y, _z, _w); | 273 return Float32x4::New(_x, _y, _z, _w); |
301 } | 274 } |
302 | 275 |
303 | |
304 DEFINE_NATIVE_ENTRY(Float32x4_setX, 2) { | 276 DEFINE_NATIVE_ENTRY(Float32x4_setX, 2) { |
305 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 277 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
306 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); | 278 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); |
307 float _x = static_cast<float>(x.value()); | 279 float _x = static_cast<float>(x.value()); |
308 float _y = self.y(); | 280 float _y = self.y(); |
309 float _z = self.z(); | 281 float _z = self.z(); |
310 float _w = self.w(); | 282 float _w = self.w(); |
311 return Float32x4::New(_x, _y, _z, _w); | 283 return Float32x4::New(_x, _y, _z, _w); |
312 } | 284 } |
313 | 285 |
314 | |
315 DEFINE_NATIVE_ENTRY(Float32x4_setY, 2) { | 286 DEFINE_NATIVE_ENTRY(Float32x4_setY, 2) { |
316 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 287 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
317 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1)); | 288 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1)); |
318 float _x = self.x(); | 289 float _x = self.x(); |
319 float _y = static_cast<float>(y.value()); | 290 float _y = static_cast<float>(y.value()); |
320 float _z = self.z(); | 291 float _z = self.z(); |
321 float _w = self.w(); | 292 float _w = self.w(); |
322 return Float32x4::New(_x, _y, _z, _w); | 293 return Float32x4::New(_x, _y, _z, _w); |
323 } | 294 } |
324 | 295 |
325 | |
326 DEFINE_NATIVE_ENTRY(Float32x4_setZ, 2) { | 296 DEFINE_NATIVE_ENTRY(Float32x4_setZ, 2) { |
327 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 297 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
328 GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(1)); | 298 GET_NON_NULL_NATIVE_ARGUMENT(Double, z, arguments->NativeArgAt(1)); |
329 float _x = self.x(); | 299 float _x = self.x(); |
330 float _y = self.y(); | 300 float _y = self.y(); |
331 float _z = static_cast<float>(z.value()); | 301 float _z = static_cast<float>(z.value()); |
332 float _w = self.w(); | 302 float _w = self.w(); |
333 return Float32x4::New(_x, _y, _z, _w); | 303 return Float32x4::New(_x, _y, _z, _w); |
334 } | 304 } |
335 | 305 |
336 | |
337 DEFINE_NATIVE_ENTRY(Float32x4_setW, 2) { | 306 DEFINE_NATIVE_ENTRY(Float32x4_setW, 2) { |
338 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 307 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
339 GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(1)); | 308 GET_NON_NULL_NATIVE_ARGUMENT(Double, w, arguments->NativeArgAt(1)); |
340 float _x = self.x(); | 309 float _x = self.x(); |
341 float _y = self.y(); | 310 float _y = self.y(); |
342 float _z = self.z(); | 311 float _z = self.z(); |
343 float _w = static_cast<float>(w.value()); | 312 float _w = static_cast<float>(w.value()); |
344 return Float32x4::New(_x, _y, _z, _w); | 313 return Float32x4::New(_x, _y, _z, _w); |
345 } | 314 } |
346 | 315 |
347 | |
348 DEFINE_NATIVE_ENTRY(Float32x4_min, 2) { | 316 DEFINE_NATIVE_ENTRY(Float32x4_min, 2) { |
349 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 317 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
350 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); | 318 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); |
351 float _x = self.x() < other.x() ? self.x() : other.x(); | 319 float _x = self.x() < other.x() ? self.x() : other.x(); |
352 float _y = self.y() < other.y() ? self.y() : other.y(); | 320 float _y = self.y() < other.y() ? self.y() : other.y(); |
353 float _z = self.z() < other.z() ? self.z() : other.z(); | 321 float _z = self.z() < other.z() ? self.z() : other.z(); |
354 float _w = self.w() < other.w() ? self.w() : other.w(); | 322 float _w = self.w() < other.w() ? self.w() : other.w(); |
355 return Float32x4::New(_x, _y, _z, _w); | 323 return Float32x4::New(_x, _y, _z, _w); |
356 } | 324 } |
357 | 325 |
358 | |
359 DEFINE_NATIVE_ENTRY(Float32x4_max, 2) { | 326 DEFINE_NATIVE_ENTRY(Float32x4_max, 2) { |
360 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 327 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
361 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); | 328 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, other, arguments->NativeArgAt(1)); |
362 float _x = self.x() > other.x() ? self.x() : other.x(); | 329 float _x = self.x() > other.x() ? self.x() : other.x(); |
363 float _y = self.y() > other.y() ? self.y() : other.y(); | 330 float _y = self.y() > other.y() ? self.y() : other.y(); |
364 float _z = self.z() > other.z() ? self.z() : other.z(); | 331 float _z = self.z() > other.z() ? self.z() : other.z(); |
365 float _w = self.w() > other.w() ? self.w() : other.w(); | 332 float _w = self.w() > other.w() ? self.w() : other.w(); |
366 return Float32x4::New(_x, _y, _z, _w); | 333 return Float32x4::New(_x, _y, _z, _w); |
367 } | 334 } |
368 | 335 |
369 | |
370 DEFINE_NATIVE_ENTRY(Float32x4_sqrt, 1) { | 336 DEFINE_NATIVE_ENTRY(Float32x4_sqrt, 1) { |
371 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 337 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
372 float _x = sqrtf(self.x()); | 338 float _x = sqrtf(self.x()); |
373 float _y = sqrtf(self.y()); | 339 float _y = sqrtf(self.y()); |
374 float _z = sqrtf(self.z()); | 340 float _z = sqrtf(self.z()); |
375 float _w = sqrtf(self.w()); | 341 float _w = sqrtf(self.w()); |
376 return Float32x4::New(_x, _y, _z, _w); | 342 return Float32x4::New(_x, _y, _z, _w); |
377 } | 343 } |
378 | 344 |
379 | |
380 DEFINE_NATIVE_ENTRY(Float32x4_reciprocal, 1) { | 345 DEFINE_NATIVE_ENTRY(Float32x4_reciprocal, 1) { |
381 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 346 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
382 float _x = 1.0f / self.x(); | 347 float _x = 1.0f / self.x(); |
383 float _y = 1.0f / self.y(); | 348 float _y = 1.0f / self.y(); |
384 float _z = 1.0f / self.z(); | 349 float _z = 1.0f / self.z(); |
385 float _w = 1.0f / self.w(); | 350 float _w = 1.0f / self.w(); |
386 return Float32x4::New(_x, _y, _z, _w); | 351 return Float32x4::New(_x, _y, _z, _w); |
387 } | 352 } |
388 | 353 |
389 | |
390 DEFINE_NATIVE_ENTRY(Float32x4_reciprocalSqrt, 1) { | 354 DEFINE_NATIVE_ENTRY(Float32x4_reciprocalSqrt, 1) { |
391 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); | 355 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, self, arguments->NativeArgAt(0)); |
392 float _x = sqrtf(1.0f / self.x()); | 356 float _x = sqrtf(1.0f / self.x()); |
393 float _y = sqrtf(1.0f / self.y()); | 357 float _y = sqrtf(1.0f / self.y()); |
394 float _z = sqrtf(1.0f / self.z()); | 358 float _z = sqrtf(1.0f / self.z()); |
395 float _w = sqrtf(1.0f / self.w()); | 359 float _w = sqrtf(1.0f / self.w()); |
396 return Float32x4::New(_x, _y, _z, _w); | 360 return Float32x4::New(_x, _y, _z, _w); |
397 } | 361 } |
398 | 362 |
399 | |
400 DEFINE_NATIVE_ENTRY(Int32x4_fromInts, 5) { | 363 DEFINE_NATIVE_ENTRY(Int32x4_fromInts, 5) { |
401 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 364 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
402 GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(1)); | 365 GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(1)); |
403 GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(2)); | 366 GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(2)); |
404 GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(3)); | 367 GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(3)); |
405 GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(4)); | 368 GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(4)); |
406 int32_t _x = static_cast<int32_t>(x.AsTruncatedUint32Value()); | 369 int32_t _x = static_cast<int32_t>(x.AsTruncatedUint32Value()); |
407 int32_t _y = static_cast<int32_t>(y.AsTruncatedUint32Value()); | 370 int32_t _y = static_cast<int32_t>(y.AsTruncatedUint32Value()); |
408 int32_t _z = static_cast<int32_t>(z.AsTruncatedUint32Value()); | 371 int32_t _z = static_cast<int32_t>(z.AsTruncatedUint32Value()); |
409 int32_t _w = static_cast<int32_t>(w.AsTruncatedUint32Value()); | 372 int32_t _w = static_cast<int32_t>(w.AsTruncatedUint32Value()); |
410 return Int32x4::New(_x, _y, _z, _w); | 373 return Int32x4::New(_x, _y, _z, _w); |
411 } | 374 } |
412 | 375 |
413 | |
414 DEFINE_NATIVE_ENTRY(Int32x4_fromBools, 5) { | 376 DEFINE_NATIVE_ENTRY(Int32x4_fromBools, 5) { |
415 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 377 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
416 GET_NON_NULL_NATIVE_ARGUMENT(Bool, x, arguments->NativeArgAt(1)); | 378 GET_NON_NULL_NATIVE_ARGUMENT(Bool, x, arguments->NativeArgAt(1)); |
417 GET_NON_NULL_NATIVE_ARGUMENT(Bool, y, arguments->NativeArgAt(2)); | 379 GET_NON_NULL_NATIVE_ARGUMENT(Bool, y, arguments->NativeArgAt(2)); |
418 GET_NON_NULL_NATIVE_ARGUMENT(Bool, z, arguments->NativeArgAt(3)); | 380 GET_NON_NULL_NATIVE_ARGUMENT(Bool, z, arguments->NativeArgAt(3)); |
419 GET_NON_NULL_NATIVE_ARGUMENT(Bool, w, arguments->NativeArgAt(4)); | 381 GET_NON_NULL_NATIVE_ARGUMENT(Bool, w, arguments->NativeArgAt(4)); |
420 int32_t _x = x.value() ? 0xFFFFFFFF : 0x0; | 382 int32_t _x = x.value() ? 0xFFFFFFFF : 0x0; |
421 int32_t _y = y.value() ? 0xFFFFFFFF : 0x0; | 383 int32_t _y = y.value() ? 0xFFFFFFFF : 0x0; |
422 int32_t _z = z.value() ? 0xFFFFFFFF : 0x0; | 384 int32_t _z = z.value() ? 0xFFFFFFFF : 0x0; |
423 int32_t _w = w.value() ? 0xFFFFFFFF : 0x0; | 385 int32_t _w = w.value() ? 0xFFFFFFFF : 0x0; |
424 return Int32x4::New(_x, _y, _z, _w); | 386 return Int32x4::New(_x, _y, _z, _w); |
425 } | 387 } |
426 | 388 |
427 | |
428 DEFINE_NATIVE_ENTRY(Int32x4_fromFloat32x4Bits, 2) { | 389 DEFINE_NATIVE_ENTRY(Int32x4_fromFloat32x4Bits, 2) { |
429 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, v, arguments->NativeArgAt(1)); | 390 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, v, arguments->NativeArgAt(1)); |
430 return Int32x4::New(v.value()); | 391 return Int32x4::New(v.value()); |
431 } | 392 } |
432 | 393 |
433 | |
434 DEFINE_NATIVE_ENTRY(Int32x4_or, 2) { | 394 DEFINE_NATIVE_ENTRY(Int32x4_or, 2) { |
435 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 395 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
436 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); | 396 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); |
437 int32_t _x = self.x() | other.x(); | 397 int32_t _x = self.x() | other.x(); |
438 int32_t _y = self.y() | other.y(); | 398 int32_t _y = self.y() | other.y(); |
439 int32_t _z = self.z() | other.z(); | 399 int32_t _z = self.z() | other.z(); |
440 int32_t _w = self.w() | other.w(); | 400 int32_t _w = self.w() | other.w(); |
441 return Int32x4::New(_x, _y, _z, _w); | 401 return Int32x4::New(_x, _y, _z, _w); |
442 } | 402 } |
443 | 403 |
444 | |
445 DEFINE_NATIVE_ENTRY(Int32x4_and, 2) { | 404 DEFINE_NATIVE_ENTRY(Int32x4_and, 2) { |
446 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 405 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
447 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); | 406 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); |
448 int32_t _x = self.x() & other.x(); | 407 int32_t _x = self.x() & other.x(); |
449 int32_t _y = self.y() & other.y(); | 408 int32_t _y = self.y() & other.y(); |
450 int32_t _z = self.z() & other.z(); | 409 int32_t _z = self.z() & other.z(); |
451 int32_t _w = self.w() & other.w(); | 410 int32_t _w = self.w() & other.w(); |
452 return Int32x4::New(_x, _y, _z, _w); | 411 return Int32x4::New(_x, _y, _z, _w); |
453 } | 412 } |
454 | 413 |
455 | |
456 DEFINE_NATIVE_ENTRY(Int32x4_xor, 2) { | 414 DEFINE_NATIVE_ENTRY(Int32x4_xor, 2) { |
457 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 415 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
458 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); | 416 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); |
459 int32_t _x = self.x() ^ other.x(); | 417 int32_t _x = self.x() ^ other.x(); |
460 int32_t _y = self.y() ^ other.y(); | 418 int32_t _y = self.y() ^ other.y(); |
461 int32_t _z = self.z() ^ other.z(); | 419 int32_t _z = self.z() ^ other.z(); |
462 int32_t _w = self.w() ^ other.w(); | 420 int32_t _w = self.w() ^ other.w(); |
463 return Int32x4::New(_x, _y, _z, _w); | 421 return Int32x4::New(_x, _y, _z, _w); |
464 } | 422 } |
465 | 423 |
466 | |
467 DEFINE_NATIVE_ENTRY(Int32x4_add, 2) { | 424 DEFINE_NATIVE_ENTRY(Int32x4_add, 2) { |
468 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 425 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
469 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); | 426 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); |
470 int32_t _x = self.x() + other.x(); | 427 int32_t _x = self.x() + other.x(); |
471 int32_t _y = self.y() + other.y(); | 428 int32_t _y = self.y() + other.y(); |
472 int32_t _z = self.z() + other.z(); | 429 int32_t _z = self.z() + other.z(); |
473 int32_t _w = self.w() + other.w(); | 430 int32_t _w = self.w() + other.w(); |
474 return Int32x4::New(_x, _y, _z, _w); | 431 return Int32x4::New(_x, _y, _z, _w); |
475 } | 432 } |
476 | 433 |
477 | |
478 DEFINE_NATIVE_ENTRY(Int32x4_sub, 2) { | 434 DEFINE_NATIVE_ENTRY(Int32x4_sub, 2) { |
479 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 435 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
480 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); | 436 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, other, arguments->NativeArgAt(1)); |
481 int32_t _x = self.x() - other.x(); | 437 int32_t _x = self.x() - other.x(); |
482 int32_t _y = self.y() - other.y(); | 438 int32_t _y = self.y() - other.y(); |
483 int32_t _z = self.z() - other.z(); | 439 int32_t _z = self.z() - other.z(); |
484 int32_t _w = self.w() - other.w(); | 440 int32_t _w = self.w() - other.w(); |
485 return Int32x4::New(_x, _y, _z, _w); | 441 return Int32x4::New(_x, _y, _z, _w); |
486 } | 442 } |
487 | 443 |
488 | |
489 DEFINE_NATIVE_ENTRY(Int32x4_getX, 1) { | 444 DEFINE_NATIVE_ENTRY(Int32x4_getX, 1) { |
490 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 445 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
491 int32_t value = self.x(); | 446 int32_t value = self.x(); |
492 return Integer::New(value); | 447 return Integer::New(value); |
493 } | 448 } |
494 | 449 |
495 | |
496 DEFINE_NATIVE_ENTRY(Int32x4_getY, 1) { | 450 DEFINE_NATIVE_ENTRY(Int32x4_getY, 1) { |
497 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 451 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
498 int32_t value = self.y(); | 452 int32_t value = self.y(); |
499 return Integer::New(value); | 453 return Integer::New(value); |
500 } | 454 } |
501 | 455 |
502 | |
503 DEFINE_NATIVE_ENTRY(Int32x4_getZ, 1) { | 456 DEFINE_NATIVE_ENTRY(Int32x4_getZ, 1) { |
504 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 457 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
505 int32_t value = self.z(); | 458 int32_t value = self.z(); |
506 return Integer::New(value); | 459 return Integer::New(value); |
507 } | 460 } |
508 | 461 |
509 | |
510 DEFINE_NATIVE_ENTRY(Int32x4_getW, 1) { | 462 DEFINE_NATIVE_ENTRY(Int32x4_getW, 1) { |
511 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 463 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
512 int32_t value = self.w(); | 464 int32_t value = self.w(); |
513 return Integer::New(value); | 465 return Integer::New(value); |
514 } | 466 } |
515 | 467 |
516 | |
517 DEFINE_NATIVE_ENTRY(Int32x4_shuffle, 2) { | 468 DEFINE_NATIVE_ENTRY(Int32x4_shuffle, 2) { |
518 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 469 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
519 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1)); | 470 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(1)); |
520 int64_t m = mask.AsInt64Value(); | 471 int64_t m = mask.AsInt64Value(); |
521 ThrowMaskRangeException(m); | 472 ThrowMaskRangeException(m); |
522 int32_t data[4] = {self.x(), self.y(), self.z(), self.w()}; | 473 int32_t data[4] = {self.x(), self.y(), self.z(), self.w()}; |
523 int32_t _x = data[m & 0x3]; | 474 int32_t _x = data[m & 0x3]; |
524 int32_t _y = data[(m >> 2) & 0x3]; | 475 int32_t _y = data[(m >> 2) & 0x3]; |
525 int32_t _z = data[(m >> 4) & 0x3]; | 476 int32_t _z = data[(m >> 4) & 0x3]; |
526 int32_t _w = data[(m >> 6) & 0x3]; | 477 int32_t _w = data[(m >> 6) & 0x3]; |
527 return Int32x4::New(_x, _y, _z, _w); | 478 return Int32x4::New(_x, _y, _z, _w); |
528 } | 479 } |
529 | 480 |
530 | |
531 DEFINE_NATIVE_ENTRY(Int32x4_shuffleMix, 3) { | 481 DEFINE_NATIVE_ENTRY(Int32x4_shuffleMix, 3) { |
532 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 482 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
533 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, zw, arguments->NativeArgAt(1)); | 483 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, zw, arguments->NativeArgAt(1)); |
534 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2)); | 484 GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(2)); |
535 int64_t m = mask.AsInt64Value(); | 485 int64_t m = mask.AsInt64Value(); |
536 ThrowMaskRangeException(m); | 486 ThrowMaskRangeException(m); |
537 int32_t data[4] = {self.x(), self.y(), self.z(), self.w()}; | 487 int32_t data[4] = {self.x(), self.y(), self.z(), self.w()}; |
538 int32_t zw_data[4] = {zw.x(), zw.y(), zw.z(), zw.w()}; | 488 int32_t zw_data[4] = {zw.x(), zw.y(), zw.z(), zw.w()}; |
539 int32_t _x = data[m & 0x3]; | 489 int32_t _x = data[m & 0x3]; |
540 int32_t _y = data[(m >> 2) & 0x3]; | 490 int32_t _y = data[(m >> 2) & 0x3]; |
541 int32_t _z = zw_data[(m >> 4) & 0x3]; | 491 int32_t _z = zw_data[(m >> 4) & 0x3]; |
542 int32_t _w = zw_data[(m >> 6) & 0x3]; | 492 int32_t _w = zw_data[(m >> 6) & 0x3]; |
543 return Int32x4::New(_x, _y, _z, _w); | 493 return Int32x4::New(_x, _y, _z, _w); |
544 } | 494 } |
545 | 495 |
546 | |
547 DEFINE_NATIVE_ENTRY(Int32x4_setX, 2) { | 496 DEFINE_NATIVE_ENTRY(Int32x4_setX, 2) { |
548 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 497 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
549 GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(1)); | 498 GET_NON_NULL_NATIVE_ARGUMENT(Integer, x, arguments->NativeArgAt(1)); |
550 int32_t _x = static_cast<int32_t>(x.AsInt64Value() & 0xFFFFFFFF); | 499 int32_t _x = static_cast<int32_t>(x.AsInt64Value() & 0xFFFFFFFF); |
551 int32_t _y = self.y(); | 500 int32_t _y = self.y(); |
552 int32_t _z = self.z(); | 501 int32_t _z = self.z(); |
553 int32_t _w = self.w(); | 502 int32_t _w = self.w(); |
554 return Int32x4::New(_x, _y, _z, _w); | 503 return Int32x4::New(_x, _y, _z, _w); |
555 } | 504 } |
556 | 505 |
557 | |
558 DEFINE_NATIVE_ENTRY(Int32x4_setY, 2) { | 506 DEFINE_NATIVE_ENTRY(Int32x4_setY, 2) { |
559 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 507 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
560 GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(1)); | 508 GET_NON_NULL_NATIVE_ARGUMENT(Integer, y, arguments->NativeArgAt(1)); |
561 int32_t _x = self.x(); | 509 int32_t _x = self.x(); |
562 int32_t _y = static_cast<int32_t>(y.AsInt64Value() & 0xFFFFFFFF); | 510 int32_t _y = static_cast<int32_t>(y.AsInt64Value() & 0xFFFFFFFF); |
563 int32_t _z = self.z(); | 511 int32_t _z = self.z(); |
564 int32_t _w = self.w(); | 512 int32_t _w = self.w(); |
565 return Int32x4::New(_x, _y, _z, _w); | 513 return Int32x4::New(_x, _y, _z, _w); |
566 } | 514 } |
567 | 515 |
568 | |
569 DEFINE_NATIVE_ENTRY(Int32x4_setZ, 2) { | 516 DEFINE_NATIVE_ENTRY(Int32x4_setZ, 2) { |
570 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 517 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
571 GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(1)); | 518 GET_NON_NULL_NATIVE_ARGUMENT(Integer, z, arguments->NativeArgAt(1)); |
572 int32_t _x = self.x(); | 519 int32_t _x = self.x(); |
573 int32_t _y = self.y(); | 520 int32_t _y = self.y(); |
574 int32_t _z = static_cast<int32_t>(z.AsInt64Value() & 0xFFFFFFFF); | 521 int32_t _z = static_cast<int32_t>(z.AsInt64Value() & 0xFFFFFFFF); |
575 int32_t _w = self.w(); | 522 int32_t _w = self.w(); |
576 return Int32x4::New(_x, _y, _z, _w); | 523 return Int32x4::New(_x, _y, _z, _w); |
577 } | 524 } |
578 | 525 |
579 | |
580 DEFINE_NATIVE_ENTRY(Int32x4_setW, 2) { | 526 DEFINE_NATIVE_ENTRY(Int32x4_setW, 2) { |
581 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 527 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
582 GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(1)); | 528 GET_NON_NULL_NATIVE_ARGUMENT(Integer, w, arguments->NativeArgAt(1)); |
583 int32_t _x = self.x(); | 529 int32_t _x = self.x(); |
584 int32_t _y = self.y(); | 530 int32_t _y = self.y(); |
585 int32_t _z = self.z(); | 531 int32_t _z = self.z(); |
586 int32_t _w = static_cast<int32_t>(w.AsInt64Value() & 0xFFFFFFFF); | 532 int32_t _w = static_cast<int32_t>(w.AsInt64Value() & 0xFFFFFFFF); |
587 return Int32x4::New(_x, _y, _z, _w); | 533 return Int32x4::New(_x, _y, _z, _w); |
588 } | 534 } |
589 | 535 |
590 | |
591 DEFINE_NATIVE_ENTRY(Int32x4_getFlagX, 1) { | 536 DEFINE_NATIVE_ENTRY(Int32x4_getFlagX, 1) { |
592 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 537 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
593 int32_t value = self.x(); | 538 int32_t value = self.x(); |
594 return Bool::Get(value != 0).raw(); | 539 return Bool::Get(value != 0).raw(); |
595 } | 540 } |
596 | 541 |
597 | |
598 DEFINE_NATIVE_ENTRY(Int32x4_getFlagY, 1) { | 542 DEFINE_NATIVE_ENTRY(Int32x4_getFlagY, 1) { |
599 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 543 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
600 int32_t value = self.y(); | 544 int32_t value = self.y(); |
601 return Bool::Get(value != 0).raw(); | 545 return Bool::Get(value != 0).raw(); |
602 } | 546 } |
603 | 547 |
604 | |
605 DEFINE_NATIVE_ENTRY(Int32x4_getFlagZ, 1) { | 548 DEFINE_NATIVE_ENTRY(Int32x4_getFlagZ, 1) { |
606 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 549 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
607 int32_t value = self.z(); | 550 int32_t value = self.z(); |
608 return Bool::Get(value != 0).raw(); | 551 return Bool::Get(value != 0).raw(); |
609 } | 552 } |
610 | 553 |
611 | |
612 DEFINE_NATIVE_ENTRY(Int32x4_getFlagW, 1) { | 554 DEFINE_NATIVE_ENTRY(Int32x4_getFlagW, 1) { |
613 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 555 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
614 int32_t value = self.w(); | 556 int32_t value = self.w(); |
615 return Bool::Get(value != 0).raw(); | 557 return Bool::Get(value != 0).raw(); |
616 } | 558 } |
617 | 559 |
618 | |
619 DEFINE_NATIVE_ENTRY(Int32x4_setFlagX, 2) { | 560 DEFINE_NATIVE_ENTRY(Int32x4_setFlagX, 2) { |
620 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 561 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
621 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagX, arguments->NativeArgAt(1)); | 562 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagX, arguments->NativeArgAt(1)); |
622 int32_t _x = self.x(); | 563 int32_t _x = self.x(); |
623 int32_t _y = self.y(); | 564 int32_t _y = self.y(); |
624 int32_t _z = self.z(); | 565 int32_t _z = self.z(); |
625 int32_t _w = self.w(); | 566 int32_t _w = self.w(); |
626 _x = flagX.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; | 567 _x = flagX.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; |
627 return Int32x4::New(_x, _y, _z, _w); | 568 return Int32x4::New(_x, _y, _z, _w); |
628 } | 569 } |
629 | 570 |
630 | |
631 DEFINE_NATIVE_ENTRY(Int32x4_setFlagY, 2) { | 571 DEFINE_NATIVE_ENTRY(Int32x4_setFlagY, 2) { |
632 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 572 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
633 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagY, arguments->NativeArgAt(1)); | 573 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagY, arguments->NativeArgAt(1)); |
634 int32_t _x = self.x(); | 574 int32_t _x = self.x(); |
635 int32_t _y = self.y(); | 575 int32_t _y = self.y(); |
636 int32_t _z = self.z(); | 576 int32_t _z = self.z(); |
637 int32_t _w = self.w(); | 577 int32_t _w = self.w(); |
638 _y = flagY.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; | 578 _y = flagY.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; |
639 return Int32x4::New(_x, _y, _z, _w); | 579 return Int32x4::New(_x, _y, _z, _w); |
640 } | 580 } |
641 | 581 |
642 | |
643 DEFINE_NATIVE_ENTRY(Int32x4_setFlagZ, 2) { | 582 DEFINE_NATIVE_ENTRY(Int32x4_setFlagZ, 2) { |
644 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 583 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
645 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagZ, arguments->NativeArgAt(1)); | 584 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagZ, arguments->NativeArgAt(1)); |
646 int32_t _x = self.x(); | 585 int32_t _x = self.x(); |
647 int32_t _y = self.y(); | 586 int32_t _y = self.y(); |
648 int32_t _z = self.z(); | 587 int32_t _z = self.z(); |
649 int32_t _w = self.w(); | 588 int32_t _w = self.w(); |
650 _z = flagZ.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; | 589 _z = flagZ.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; |
651 return Int32x4::New(_x, _y, _z, _w); | 590 return Int32x4::New(_x, _y, _z, _w); |
652 } | 591 } |
653 | 592 |
654 | |
655 DEFINE_NATIVE_ENTRY(Int32x4_setFlagW, 2) { | 593 DEFINE_NATIVE_ENTRY(Int32x4_setFlagW, 2) { |
656 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 594 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
657 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagW, arguments->NativeArgAt(1)); | 595 GET_NON_NULL_NATIVE_ARGUMENT(Bool, flagW, arguments->NativeArgAt(1)); |
658 int32_t _x = self.x(); | 596 int32_t _x = self.x(); |
659 int32_t _y = self.y(); | 597 int32_t _y = self.y(); |
660 int32_t _z = self.z(); | 598 int32_t _z = self.z(); |
661 int32_t _w = self.w(); | 599 int32_t _w = self.w(); |
662 _w = flagW.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; | 600 _w = flagW.raw() == Bool::True().raw() ? 0xFFFFFFFF : 0x0; |
663 return Int32x4::New(_x, _y, _z, _w); | 601 return Int32x4::New(_x, _y, _z, _w); |
664 } | 602 } |
665 | 603 |
666 | |
667 // Used to convert between int32_t and float32 without breaking strict | 604 // Used to convert between int32_t and float32 without breaking strict |
668 // aliasing rules. | 605 // aliasing rules. |
669 union float32_int32 { | 606 union float32_int32 { |
670 float f; | 607 float f; |
671 int32_t u; | 608 int32_t u; |
672 float32_int32(float v) { f = v; } | 609 float32_int32(float v) { f = v; } |
673 float32_int32(int32_t v) { u = v; } | 610 float32_int32(int32_t v) { u = v; } |
674 }; | 611 }; |
675 | 612 |
676 | |
677 DEFINE_NATIVE_ENTRY(Int32x4_select, 3) { | 613 DEFINE_NATIVE_ENTRY(Int32x4_select, 3) { |
678 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); | 614 GET_NON_NULL_NATIVE_ARGUMENT(Int32x4, self, arguments->NativeArgAt(0)); |
679 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, tv, arguments->NativeArgAt(1)); | 615 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, tv, arguments->NativeArgAt(1)); |
680 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, fv, arguments->NativeArgAt(2)); | 616 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, fv, arguments->NativeArgAt(2)); |
681 int32_t _maskX = self.x(); | 617 int32_t _maskX = self.x(); |
682 int32_t _maskY = self.y(); | 618 int32_t _maskY = self.y(); |
683 int32_t _maskZ = self.z(); | 619 int32_t _maskZ = self.z(); |
684 int32_t _maskW = self.w(); | 620 int32_t _maskW = self.w(); |
685 // Extract floats and interpret them as masks. | 621 // Extract floats and interpret them as masks. |
686 float32_int32 tvx(tv.x()); | 622 float32_int32 tvx(tv.x()); |
687 float32_int32 tvy(tv.y()); | 623 float32_int32 tvy(tv.y()); |
688 float32_int32 tvz(tv.z()); | 624 float32_int32 tvz(tv.z()); |
689 float32_int32 tvw(tv.w()); | 625 float32_int32 tvw(tv.w()); |
690 float32_int32 fvx(fv.x()); | 626 float32_int32 fvx(fv.x()); |
691 float32_int32 fvy(fv.y()); | 627 float32_int32 fvy(fv.y()); |
692 float32_int32 fvz(fv.z()); | 628 float32_int32 fvz(fv.z()); |
693 float32_int32 fvw(fv.w()); | 629 float32_int32 fvw(fv.w()); |
694 // Perform select. | 630 // Perform select. |
695 float32_int32 tempX((_maskX & tvx.u) | (~_maskX & fvx.u)); | 631 float32_int32 tempX((_maskX & tvx.u) | (~_maskX & fvx.u)); |
696 float32_int32 tempY((_maskY & tvy.u) | (~_maskY & fvy.u)); | 632 float32_int32 tempY((_maskY & tvy.u) | (~_maskY & fvy.u)); |
697 float32_int32 tempZ((_maskZ & tvz.u) | (~_maskZ & fvz.u)); | 633 float32_int32 tempZ((_maskZ & tvz.u) | (~_maskZ & fvz.u)); |
698 float32_int32 tempW((_maskW & tvw.u) | (~_maskW & fvw.u)); | 634 float32_int32 tempW((_maskW & tvw.u) | (~_maskW & fvw.u)); |
699 return Float32x4::New(tempX.f, tempY.f, tempZ.f, tempW.f); | 635 return Float32x4::New(tempX.f, tempY.f, tempZ.f, tempW.f); |
700 } | 636 } |
701 | 637 |
702 | |
703 DEFINE_NATIVE_ENTRY(Float64x2_fromDoubles, 3) { | 638 DEFINE_NATIVE_ENTRY(Float64x2_fromDoubles, 3) { |
704 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 639 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
705 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); | 640 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); |
706 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(2)); | 641 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(2)); |
707 return Float64x2::New(x.value(), y.value()); | 642 return Float64x2::New(x.value(), y.value()); |
708 } | 643 } |
709 | 644 |
710 | |
711 DEFINE_NATIVE_ENTRY(Float64x2_splat, 2) { | 645 DEFINE_NATIVE_ENTRY(Float64x2_splat, 2) { |
712 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 646 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
713 GET_NON_NULL_NATIVE_ARGUMENT(Double, v, arguments->NativeArgAt(1)); | 647 GET_NON_NULL_NATIVE_ARGUMENT(Double, v, arguments->NativeArgAt(1)); |
714 return Float64x2::New(v.value(), v.value()); | 648 return Float64x2::New(v.value(), v.value()); |
715 } | 649 } |
716 | 650 |
717 | |
718 DEFINE_NATIVE_ENTRY(Float64x2_zero, 1) { | 651 DEFINE_NATIVE_ENTRY(Float64x2_zero, 1) { |
719 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 652 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
720 return Float64x2::New(0.0, 0.0); | 653 return Float64x2::New(0.0, 0.0); |
721 } | 654 } |
722 | 655 |
723 | |
724 DEFINE_NATIVE_ENTRY(Float64x2_fromFloat32x4, 2) { | 656 DEFINE_NATIVE_ENTRY(Float64x2_fromFloat32x4, 2) { |
725 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); | 657 ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull()); |
726 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, v, arguments->NativeArgAt(1)); | 658 GET_NON_NULL_NATIVE_ARGUMENT(Float32x4, v, arguments->NativeArgAt(1)); |
727 double _x = v.x(); | 659 double _x = v.x(); |
728 double _y = v.y(); | 660 double _y = v.y(); |
729 return Float64x2::New(_x, _y); | 661 return Float64x2::New(_x, _y); |
730 } | 662 } |
731 | 663 |
732 | |
733 DEFINE_NATIVE_ENTRY(Float64x2_add, 2) { | 664 DEFINE_NATIVE_ENTRY(Float64x2_add, 2) { |
734 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 665 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
735 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); | 666 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); |
736 double _x = self.x() + other.x(); | 667 double _x = self.x() + other.x(); |
737 double _y = self.y() + other.y(); | 668 double _y = self.y() + other.y(); |
738 return Float64x2::New(_x, _y); | 669 return Float64x2::New(_x, _y); |
739 } | 670 } |
740 | 671 |
741 | |
742 DEFINE_NATIVE_ENTRY(Float64x2_negate, 1) { | 672 DEFINE_NATIVE_ENTRY(Float64x2_negate, 1) { |
743 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 673 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
744 double _x = -self.x(); | 674 double _x = -self.x(); |
745 double _y = -self.y(); | 675 double _y = -self.y(); |
746 return Float64x2::New(_x, _y); | 676 return Float64x2::New(_x, _y); |
747 } | 677 } |
748 | 678 |
749 | |
750 DEFINE_NATIVE_ENTRY(Float64x2_sub, 2) { | 679 DEFINE_NATIVE_ENTRY(Float64x2_sub, 2) { |
751 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 680 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
752 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); | 681 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); |
753 double _x = self.x() - other.x(); | 682 double _x = self.x() - other.x(); |
754 double _y = self.y() - other.y(); | 683 double _y = self.y() - other.y(); |
755 return Float64x2::New(_x, _y); | 684 return Float64x2::New(_x, _y); |
756 } | 685 } |
757 | 686 |
758 | |
759 DEFINE_NATIVE_ENTRY(Float64x2_mul, 2) { | 687 DEFINE_NATIVE_ENTRY(Float64x2_mul, 2) { |
760 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 688 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
761 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); | 689 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); |
762 double _x = self.x() * other.x(); | 690 double _x = self.x() * other.x(); |
763 double _y = self.y() * other.y(); | 691 double _y = self.y() * other.y(); |
764 return Float64x2::New(_x, _y); | 692 return Float64x2::New(_x, _y); |
765 } | 693 } |
766 | 694 |
767 | |
768 DEFINE_NATIVE_ENTRY(Float64x2_div, 2) { | 695 DEFINE_NATIVE_ENTRY(Float64x2_div, 2) { |
769 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 696 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
770 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); | 697 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); |
771 double _x = self.x() / other.x(); | 698 double _x = self.x() / other.x(); |
772 double _y = self.y() / other.y(); | 699 double _y = self.y() / other.y(); |
773 return Float64x2::New(_x, _y); | 700 return Float64x2::New(_x, _y); |
774 } | 701 } |
775 | 702 |
776 | |
777 DEFINE_NATIVE_ENTRY(Float64x2_scale, 2) { | 703 DEFINE_NATIVE_ENTRY(Float64x2_scale, 2) { |
778 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 704 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
779 GET_NON_NULL_NATIVE_ARGUMENT(Double, scale, arguments->NativeArgAt(1)); | 705 GET_NON_NULL_NATIVE_ARGUMENT(Double, scale, arguments->NativeArgAt(1)); |
780 double _s = scale.value(); | 706 double _s = scale.value(); |
781 double _x = self.x() * _s; | 707 double _x = self.x() * _s; |
782 double _y = self.y() * _s; | 708 double _y = self.y() * _s; |
783 return Float64x2::New(_x, _y); | 709 return Float64x2::New(_x, _y); |
784 } | 710 } |
785 | 711 |
786 | |
787 DEFINE_NATIVE_ENTRY(Float64x2_abs, 1) { | 712 DEFINE_NATIVE_ENTRY(Float64x2_abs, 1) { |
788 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 713 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
789 double _x = fabs(self.x()); | 714 double _x = fabs(self.x()); |
790 double _y = fabs(self.y()); | 715 double _y = fabs(self.y()); |
791 return Float64x2::New(_x, _y); | 716 return Float64x2::New(_x, _y); |
792 } | 717 } |
793 | 718 |
794 | |
795 DEFINE_NATIVE_ENTRY(Float64x2_clamp, 3) { | 719 DEFINE_NATIVE_ENTRY(Float64x2_clamp, 3) { |
796 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 720 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
797 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, lo, arguments->NativeArgAt(1)); | 721 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, lo, arguments->NativeArgAt(1)); |
798 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, hi, arguments->NativeArgAt(2)); | 722 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, hi, arguments->NativeArgAt(2)); |
799 // The order of the clamping must match the order of the optimized code: | 723 // The order of the clamping must match the order of the optimized code: |
800 // MAX(MIN(self, hi), lo). | 724 // MAX(MIN(self, hi), lo). |
801 double _x = self.x() < hi.x() ? self.x() : hi.x(); | 725 double _x = self.x() < hi.x() ? self.x() : hi.x(); |
802 double _y = self.y() < hi.y() ? self.y() : hi.y(); | 726 double _y = self.y() < hi.y() ? self.y() : hi.y(); |
803 _x = _x < lo.x() ? lo.x() : _x; | 727 _x = _x < lo.x() ? lo.x() : _x; |
804 _y = _y < lo.y() ? lo.y() : _y; | 728 _y = _y < lo.y() ? lo.y() : _y; |
805 return Float64x2::New(_x, _y); | 729 return Float64x2::New(_x, _y); |
806 } | 730 } |
807 | 731 |
808 | |
809 DEFINE_NATIVE_ENTRY(Float64x2_getX, 1) { | 732 DEFINE_NATIVE_ENTRY(Float64x2_getX, 1) { |
810 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 733 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
811 return Double::New(self.x()); | 734 return Double::New(self.x()); |
812 } | 735 } |
813 | 736 |
814 | |
815 DEFINE_NATIVE_ENTRY(Float64x2_getY, 1) { | 737 DEFINE_NATIVE_ENTRY(Float64x2_getY, 1) { |
816 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 738 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
817 return Double::New(self.y()); | 739 return Double::New(self.y()); |
818 } | 740 } |
819 | 741 |
820 | |
821 DEFINE_NATIVE_ENTRY(Float64x2_getSignMask, 1) { | 742 DEFINE_NATIVE_ENTRY(Float64x2_getSignMask, 1) { |
822 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 743 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
823 uint32_t mx = (bit_cast<uint64_t>(self.x()) & 0x8000000000000000LL) >> 63; | 744 uint32_t mx = (bit_cast<uint64_t>(self.x()) & 0x8000000000000000LL) >> 63; |
824 uint32_t my = (bit_cast<uint64_t>(self.y()) & 0x8000000000000000LL) >> 63; | 745 uint32_t my = (bit_cast<uint64_t>(self.y()) & 0x8000000000000000LL) >> 63; |
825 uint32_t value = mx | (my << 1); | 746 uint32_t value = mx | (my << 1); |
826 return Integer::New(value); | 747 return Integer::New(value); |
827 } | 748 } |
828 | 749 |
829 | |
830 DEFINE_NATIVE_ENTRY(Float64x2_setX, 2) { | 750 DEFINE_NATIVE_ENTRY(Float64x2_setX, 2) { |
831 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 751 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
832 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); | 752 GET_NON_NULL_NATIVE_ARGUMENT(Double, x, arguments->NativeArgAt(1)); |
833 double _x = x.value(); | 753 double _x = x.value(); |
834 double _y = self.y(); | 754 double _y = self.y(); |
835 return Float64x2::New(_x, _y); | 755 return Float64x2::New(_x, _y); |
836 } | 756 } |
837 | 757 |
838 | |
839 DEFINE_NATIVE_ENTRY(Float64x2_setY, 2) { | 758 DEFINE_NATIVE_ENTRY(Float64x2_setY, 2) { |
840 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 759 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
841 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1)); | 760 GET_NON_NULL_NATIVE_ARGUMENT(Double, y, arguments->NativeArgAt(1)); |
842 double _x = self.x(); | 761 double _x = self.x(); |
843 double _y = y.value(); | 762 double _y = y.value(); |
844 return Float64x2::New(_x, _y); | 763 return Float64x2::New(_x, _y); |
845 } | 764 } |
846 | 765 |
847 | |
848 DEFINE_NATIVE_ENTRY(Float64x2_min, 2) { | 766 DEFINE_NATIVE_ENTRY(Float64x2_min, 2) { |
849 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 767 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
850 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); | 768 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); |
851 double _x = self.x() < other.x() ? self.x() : other.x(); | 769 double _x = self.x() < other.x() ? self.x() : other.x(); |
852 double _y = self.y() < other.y() ? self.y() : other.y(); | 770 double _y = self.y() < other.y() ? self.y() : other.y(); |
853 return Float64x2::New(_x, _y); | 771 return Float64x2::New(_x, _y); |
854 } | 772 } |
855 | 773 |
856 | |
857 DEFINE_NATIVE_ENTRY(Float64x2_max, 2) { | 774 DEFINE_NATIVE_ENTRY(Float64x2_max, 2) { |
858 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 775 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
859 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); | 776 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, other, arguments->NativeArgAt(1)); |
860 double _x = self.x() > other.x() ? self.x() : other.x(); | 777 double _x = self.x() > other.x() ? self.x() : other.x(); |
861 double _y = self.y() > other.y() ? self.y() : other.y(); | 778 double _y = self.y() > other.y() ? self.y() : other.y(); |
862 return Float64x2::New(_x, _y); | 779 return Float64x2::New(_x, _y); |
863 } | 780 } |
864 | 781 |
865 | |
866 DEFINE_NATIVE_ENTRY(Float64x2_sqrt, 1) { | 782 DEFINE_NATIVE_ENTRY(Float64x2_sqrt, 1) { |
867 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); | 783 GET_NON_NULL_NATIVE_ARGUMENT(Float64x2, self, arguments->NativeArgAt(0)); |
868 double _x = sqrt(self.x()); | 784 double _x = sqrt(self.x()); |
869 double _y = sqrt(self.y()); | 785 double _y = sqrt(self.y()); |
870 return Float64x2::New(_x, _y); | 786 return Float64x2::New(_x, _y); |
871 } | 787 } |
872 | 788 |
873 } // namespace dart | 789 } // namespace dart |
OLD | NEW |