Make JetStream 2
[WebKit-https.git] / PerformanceTests / JetStream2 / WSL / StandardLibrary.js
1 /*
2  * Copyright (C) 2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25 "use strict";
26
27 // NOTE: The next line is line 28, and we rely on this in Prepare.js.
28 let standardLibrary = `
29 // This is the WSL standard library. Implementations of all of these things are in
30 // Intrinsics.js.
31
32 // Need to bootstrap void first.
33 native typedef void;
34
35 native typedef uint8;
36 native typedef int32;
37 native typedef uint32;
38 native typedef bool;
39 typedef int = int32;
40 typedef uint = uint32;
41
42 native typedef float32;
43 native typedef float64;
44 typedef float = float32;
45 typedef double = float64;
46
47 native operator int32(uint32);
48 native operator int32(uint8);
49 native operator int32(float);
50 native operator int32(double);
51 native operator uint32(int32);
52 native operator uint32(uint8);
53 native operator uint32(float);
54 native operator uint32(double);
55 native operator uint8(int32);
56 native operator uint8(uint32);
57 native operator uint8(float);
58 native operator uint8(double);
59 native operator float(int32);
60 native operator float(uint32);
61 native operator float(uint8);
62 native operator float(double);
63 native operator double(float);
64 native operator double(int32);
65 native operator double(uint32);
66 native operator double(uint8);
67
68 native int operator+(int, int);
69 native uint operator+(uint, uint);
70 uint8 operator+(uint8 a, uint8 b) { return uint8(uint(a) + uint(b)); }
71 native float operator+(float, float);
72 native double operator+(double, double);
73 int operator++(int value) { return value + 1; }
74 uint operator++(uint value) { return value + 1; }
75 uint8 operator++(uint8 value) { return value + 1; }
76 native int operator-(int, int);
77 native uint operator-(uint, uint);
78 uint8 operator-(uint8 a, uint8 b) { return uint8(uint(a) - uint(b)); }
79 native float operator-(float, float);
80 native double operator-(double, double);
81 int operator--(int value) { return value - 1; }
82 uint operator--(uint value) { return value - 1; }
83 uint8 operator--(uint8 value) { return value - 1; }
84 native int operator*(int, int);
85 native uint operator*(uint, uint);
86 uint8 operator*(uint8 a, uint8 b) { return uint8(uint(a) * uint(b)); }
87 native float operator*(float, float);
88 native double operator*(double, double);
89 native int operator/(int, int);
90 native uint operator/(uint, uint);
91 uint8 operator/(uint8 a, uint8 b) { return uint8(uint(a) / uint(b)); }
92 native int operator&(int, int);
93 native int operator|(int, int);
94 native int operator^(int, int);
95 native int operator~(int);
96 native int operator<<(int, uint);
97 native int operator>>(int, uint);
98 native uint operator&(uint, uint);
99 native uint operator|(uint, uint);
100 native uint operator^(uint, uint);
101 native uint operator~(uint);
102 native uint operator<<(uint, uint);
103 native uint operator>>(uint, uint);
104 uint8 operator&(uint8 a, uint8 b) { return uint8(uint(a) & uint(b)); }
105 uint8 operator|(uint8 a, uint8 b) { return uint8(uint(a) | uint(b)); }
106 uint8 operator^(uint8 a, uint8 b) { return uint8(uint(a) ^ uint(b)); }
107 uint8 operator~(uint8 value) { return uint8(~uint(value)); }
108 uint8 operator<<(uint8 a, uint b) { return uint8(uint(a) << (b & 7)); }
109 uint8 operator>>(uint8 a, uint b) { return uint8(uint(a) >> (b & 7)); }
110 native float operator/(float, float);
111 native double operator/(double, double);
112 native bool operator==(int, int);
113 native bool operator==(uint, uint);
114 bool operator==(uint8 a, uint8 b) { return uint(a) == uint(b); }
115 native bool operator==(bool, bool);
116 native bool operator==(float, float);
117 native bool operator==(double, double);
118 native bool operator<(int, int);
119 native bool operator<(uint, uint);
120 bool operator<(uint8 a, uint8 b) { return uint(a) < uint(b); }
121 native bool operator<(float, float);
122 native bool operator<(double, double);
123 native bool operator<=(int, int);
124 native bool operator<=(uint, uint);
125 bool operator<=(uint8 a, uint8 b) { return uint(a) <= uint(b); }
126 native bool operator<=(float, float);
127 native bool operator<=(double, double);
128 native bool operator>(int, int);
129 native bool operator>(uint, uint);
130 bool operator>(uint8 a, uint8 b) { return uint(a) > uint(b); }
131 native bool operator>(float, float);
132 native bool operator>(double, double);
133 native bool operator>=(int, int);
134 native bool operator>=(uint, uint);
135 bool operator>=(uint8 a, uint8 b) { return uint(a) >= uint(b); }
136 native bool operator>=(float, float);
137 native bool operator>=(double, double);
138
139 bool operator&(bool a, bool b)
140 {
141     if (a)
142         return b;
143     return false;
144 }
145
146 bool operator|(bool a, bool b)
147 {
148     if (a)
149         return true;
150     if (b)
151         return true;
152     return false;
153 }
154
155 bool operator^(bool a, bool b)
156 {
157     if (a)
158         return !b;
159     return b;
160 }
161
162 bool operator~(bool value)
163 {
164     return !value;
165 }
166
167 protocol Addable {
168     Addable operator+(Addable, Addable);
169 }
170
171 protocol Equatable {
172     bool operator==(Equatable, Equatable);
173 }
174
175 restricted operator<T> T()
176 {
177     T defaultValue;
178     return defaultValue;
179 }
180
181 restricted operator<T> T(T x)
182 {
183     return x;
184 }
185
186 operator<T:Equatable> bool(T x)
187 {
188     return x != T();
189 }
190
191 struct vec2<T> {
192     T x;
193     T y;
194 }
195
196 typedef int2 = vec2<int>;
197 typedef uint2 = vec2<uint>;
198 typedef float2 = vec2<float>;
199 typedef double2 = vec2<double>;
200
201 operator<T> vec2<T>(T x, T y)
202 {
203     vec2<T> result;
204     result.x = x;
205     result.y = y;
206     return result;
207 }
208
209 bool operator==<T:Equatable>(vec2<T> a, vec2<T> b)
210 {
211     return a.x == b.x && a.y == b.y;
212 }
213
214 thread T* operator&[]<T>(thread vec2<T>* foo, uint index)
215 {
216     if (index == 0)
217         return &foo->x;
218     if (index == 1)
219         return &foo->y;
220     trap;
221 }
222
223 struct vec3<T> {
224     T x;
225     T y;
226     T z;
227 }
228
229 typedef int3 = vec3<int>;
230 typedef uint3 = vec3<uint>;
231 typedef float3 = vec3<float>;
232 typedef double3 = vec3<double>;
233
234 operator<T> vec3<T>(T x, T y, T z)
235 {
236     vec3<T> result;
237     result.x = x;
238     result.y = y;
239     result.z = z;
240     return result;
241 }
242
243 operator<T> vec3<T>(vec2<T> v2, T z)
244 {
245     vec3<T> result;
246     result.x = v2.x;
247     result.y = v2.y;
248     result.z = z;
249     return result;
250 }
251
252 operator<T> vec3<T>(T x, vec2<T> v2)
253 {
254     vec3<T> result;
255     result.x = x;
256     result.y = v2.x;
257     result.z = v2.y;
258     return result;
259 }
260
261 bool operator==<T:Equatable>(vec3<T> a, vec3<T> b)
262 {
263     return a.x == b.x && a.y == b.y && a.z == b.z;
264 }
265
266 thread T* operator&[]<T>(thread vec3<T>* foo, uint index)
267 {
268     if (index == 0)
269         return &foo->x;
270     if (index == 1)
271         return &foo->y;
272     if (index == 2)
273         return &foo->z;
274     trap;
275 }
276
277 struct vec4<T> {
278     T x;
279     T y;
280     T z;
281     T w;
282 }
283
284 typedef int4 = vec4<int>;
285 typedef uint4 = vec4<uint>;
286 typedef float4 = vec4<float>;
287 typedef double4 = vec4<double>;
288
289 operator<T> vec4<T>(T x, T y, T z, T w)
290 {
291     vec4<T> result;
292     result.x = x;
293     result.y = y;
294     result.z = z;
295     result.w = w;
296     return result;
297 }
298
299 operator<T> vec4<T>(vec2<T> v2, T z, T w)
300 {
301     vec4<T> result;
302     result.x = v2.x;
303     result.y = v2.y;
304     result.z = z;
305     result.w = w;
306     return result;
307 }
308
309 operator<T> vec4<T>(T x, vec2<T> v2, T w)
310 {
311     vec4<T> result;
312     result.x = x;
313     result.y = v2.x;
314     result.z = v2.y;
315     result.w = w;
316     return result;
317 }
318
319 operator<T> vec4<T>(T x, T y, vec2<T> v2)
320 {
321     vec4<T> result;
322     result.x = x;
323     result.y = y;
324     result.z = v2.x;
325     result.w = v2.y;
326     return result;
327 }
328
329 operator<T> vec4<T>(vec2<T> v2a, vec2<T> v2b)
330 {
331     vec4<T> result;
332     result.x = v2a.x;
333     result.y = v2a.y;
334     result.z = v2b.x;
335     result.w = v2b.y;
336     return result;
337 }
338
339 operator<T> vec4<T>(vec3<T> v3, T w)
340 {
341     vec4<T> result;
342     result.x = v3.x;
343     result.y = v3.y;
344     result.z = v3.z;
345     result.w = w;
346     return result;
347 }
348
349 operator<T> vec4<T>(T x, vec3<T> v3)
350 {
351     vec4<T> result;
352     result.x = x;
353     result.y = v3.x;
354     result.z = v3.y;
355     result.w = v3.z;
356     return result;
357 }
358
359 bool operator==<T:Equatable>(vec4<T> a, vec4<T> b)
360 {
361     return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
362 }
363
364 thread T* operator&[]<T>(thread vec4<T>* foo, uint index)
365 {
366     if (index == 0)
367         return &foo->x;
368     if (index == 1)
369         return &foo->y;
370     if (index == 2)
371         return &foo->z;
372     if (index == 3)
373         return &foo->w;
374     trap;
375 }
376
377 native thread T* operator&[]<T>(thread T[], uint);
378 native threadgroup T* operator&[]<T>(threadgroup T[], uint);
379 native device T* operator&[]<T>(device T[], uint);
380 native constant T* operator&[]<T>(constant T[], uint);
381
382 native uint operator.length<T>(thread T[]);
383 native uint operator.length<T>(threadgroup T[]);
384 native uint operator.length<T>(device T[]);
385 native uint operator.length<T>(constant T[]);
386
387 uint operator.length<T, uint length>(T[length])
388 {
389     return length;
390 }
391 `;
392
393 function intToString(x)
394 {
395     switch (x) {
396     case 0:
397         return "x";
398     case 1:
399         return "y";
400     case 2:
401         return "z";
402     case 3:
403         return "w";
404     default:
405         throw new Error("Could not generate standard library.");
406     }
407 }
408
409 // There are 481 swizzle operators. Let's not list them explicitly.
410 function _generateSwizzle(maxDepth, maxItems, array)
411 {
412     if (!array)
413         array = [];
414     if (array.length == maxDepth) {
415         let result = `vec${array.length}<T> operator.${array.join("")}<T>(vec${maxItems}<T> v)
416 {
417     vec${array.length}<T> result;
418 `;
419         for (let i = 0; i < array.length; ++i) {
420             result += `    result.${intToString(i)} = v.${array[i]};
421 `;
422         }
423         result += `    return result;
424 }
425 `;
426         return result;
427     }
428     let result = "";
429     for (let i = 0; i < maxItems; ++i) {
430         array.push(intToString(i));
431         result += _generateSwizzle(maxDepth, maxItems, array);
432         array.pop();
433     }
434     return result;
435 }
436
437 for (let maxDepth = 2; maxDepth <= 4; maxDepth++) {
438     for (let maxItems = 2; maxItems <= 4; maxItems++)
439         standardLibrary += _generateSwizzle(maxDepth, maxItems);
440 }