WSL should be able to trap when something fatal happens
[WebKit-https.git] / Tools / WebGPUShadingLanguageRI / 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 const standardLibrary = `
29 // This is the WSL standard library. Implementations of all of these things are in
30 // Intrinsics.js. The only thing that gets defined before we get here is the Primitive
31 // protocol.
32
33 // Need to bootstrap void first.
34 native Primitive typedef void;
35
36 native Primitive typedef int32;
37 native Primitive typedef uint32;
38 native Primitive typedef bool;
39 typedef int = int32;
40 typedef uint = uint32;
41
42 native Primitive typedef float;
43 native Primitive typedef double;
44
45 native operator int32(uint32);
46 native operator uint32(int32);
47 native operator float(double);
48 native operator double(float);
49
50 native int operator+(int, int);
51 native uint operator+(uint, uint);
52 native float operator+(float, float);
53 native double operator+(double, double);
54 int operator++(int value) { return value + 1; }
55 uint operator++(uint value) { return value + 1; }
56 native int operator-(int, int);
57 native uint operator-(uint, uint);
58 native float operator-(float, float);
59 native double operator-(double, double);
60 int operator--(int value) { return value - 1; }
61 uint operator--(uint value) { return value - 1; }
62 native int operator*(int, int);
63 native uint operator*(uint, uint);
64 native float operator*(float, float);
65 native double operator*(double, double);
66 native int operator/(int, int);
67 native uint operator/(uint, uint);
68 native int operator&(int, int);
69 native int operator|(int, int);
70 native int operator^(int, int);
71 native int operator~(int);
72 native int operator<<(int, uint);
73 native int operator>>(int, uint);
74 native uint operator&(uint, uint);
75 native uint operator|(uint, uint);
76 native uint operator^(uint, uint);
77 native uint operator~(uint);
78 native uint operator<<(uint, uint);
79 native uint operator>>(uint, uint);
80 native float operator/(float, float);
81 native double operator/(double, double);
82 native bool operator==(int, int);
83 native bool operator==(uint, uint);
84 native bool operator==(bool, bool);
85 native bool operator==(float, float);
86 native bool operator==(double, double);
87 native bool operator<(int, int);
88 native bool operator<(uint, uint);
89 native bool operator<(float, float);
90 native bool operator<(double, double);
91 native bool operator<=(int, int);
92 native bool operator<=(uint, uint);
93 native bool operator<=(float, float);
94 native bool operator<=(double, double);
95 native bool operator>(int, int);
96 native bool operator>(uint, uint);
97 native bool operator>(float, float);
98 native bool operator>(double, double);
99 native bool operator>=(int, int);
100 native bool operator>=(uint, uint);
101 native bool operator>=(float, float);
102 native bool operator>=(double, double);
103
104 bool operator&(bool a, bool b)
105 {
106     if (a)
107         return b;
108     return false;
109 }
110
111 bool operator|(bool a, bool b)
112 {
113     if (a)
114         return true;
115     if (b)
116         return true;
117     return false;
118 }
119
120 bool operator^(bool a, bool b)
121 {
122     if (a)
123         return !b;
124     return b;
125 }
126
127 bool operator~(bool value)
128 {
129     return !value;
130 }
131
132 protocol Addable {
133     Addable operator+(Addable, Addable);
134 }
135
136 protocol Equatable {
137     bool operator==(Equatable, Equatable);
138 }
139
140 restricted operator<T> T()
141 {
142     T defaultValue;
143     return defaultValue;
144 }
145
146 restricted operator<T> T(T x)
147 {
148     return x;
149 }
150
151 operator<T:Equatable> bool(T x)
152 {
153     return x != T();
154 }
155
156 struct vec2<T> {
157     T x;
158     T y;
159 }
160
161 typedef int2 = vec2<int>;
162 typedef uint2 = vec2<uint>;
163 typedef float2 = vec2<float>;
164 typedef double2 = vec2<double>;
165
166 operator<T> vec2<T>(T x, T y)
167 {
168     vec2<T> result;
169     result.x = x;
170     result.y = y;
171     return result;
172 }
173
174 bool operator==<T:Equatable>(vec2<T> a, vec2<T> b)
175 {
176     return a.x == b.x && a.y == b.y;
177 }
178
179 thread T^ operator&[]<T>(thread vec2<T>^ foo, uint index)
180 {
181     if (index == 0)
182         return &foo->x;
183     if (index == 1)
184         return &foo->y;
185     trap;
186 }
187
188 struct vec3<T> {
189     T x;
190     T y;
191     T z;
192 }
193
194 typedef int3 = vec3<int>;
195 typedef uint3 = vec3<uint>;
196 typedef float3 = vec3<float>;
197 typedef double3 = vec3<double>;
198
199 operator<T> vec3<T>(T x, T y, T z)
200 {
201     vec3<T> result;
202     result.x = x;
203     result.y = y;
204     result.z = z;
205     return result;
206 }
207
208 operator<T> vec3<T>(vec2<T> v2, T z)
209 {
210     vec3<T> result;
211     result.x = v2.x;
212     result.y = v2.y;
213     result.z = z;
214     return result;
215 }
216
217 operator<T> vec3<T>(T x, vec2<T> v2)
218 {
219     vec3<T> result;
220     result.x = x;
221     result.y = v2.x;
222     result.z = v2.y;
223     return result;
224 }
225
226 bool operator==<T:Equatable>(vec3<T> a, vec3<T> b)
227 {
228     return a.x == b.x && a.y == b.y && a.z == b.z;
229 }
230
231 thread T^ operator&[]<T>(thread vec3<T>^ foo, uint index)
232 {
233     if (index == 0)
234         return &foo->x;
235     if (index == 1)
236         return &foo->y;
237     if (index == 2)
238         return &foo->z;
239     trap;
240 }
241
242 struct vec4<T> {
243     T x;
244     T y;
245     T z;
246     T w;
247 }
248
249 typedef int4 = vec4<int>;
250 typedef uint4 = vec4<uint>;
251 typedef float4 = vec4<float>;
252 typedef double4 = vec4<double>;
253
254 operator<T> vec4<T>(T x, T y, T z, T w)
255 {
256     vec4<T> result;
257     result.x = x;
258     result.y = y;
259     result.z = z;
260     result.w = w;
261     return result;
262 }
263
264 operator<T> vec4<T>(vec2<T> v2, T z, T w)
265 {
266     vec4<T> result;
267     result.x = v2.x;
268     result.y = v2.y;
269     result.z = z;
270     result.w = w;
271     return result;
272 }
273
274 operator<T> vec4<T>(T x, vec2<T> v2, T w)
275 {
276     vec4<T> result;
277     result.x = x;
278     result.y = v2.x;
279     result.z = v2.y;
280     result.w = w;
281     return result;
282 }
283
284 operator<T> vec4<T>(T x, T y, vec2<T> v2)
285 {
286     vec4<T> result;
287     result.x = x;
288     result.y = y;
289     result.z = v2.x;
290     result.w = v2.y;
291     return result;
292 }
293
294 operator<T> vec4<T>(vec2<T> v2a, vec2<T> v2b)
295 {
296     vec4<T> result;
297     result.x = v2a.x;
298     result.y = v2a.y;
299     result.z = v2b.x;
300     result.w = v2b.y;
301     return result;
302 }
303
304 operator<T> vec4<T>(vec3<T> v3, T w)
305 {
306     vec4<T> result;
307     result.x = v3.x;
308     result.y = v3.y;
309     result.z = v3.z;
310     result.w = w;
311     return result;
312 }
313
314 operator<T> vec4<T>(T x, vec3<T> v3)
315 {
316     vec4<T> result;
317     result.x = x;
318     result.y = v3.x;
319     result.z = v3.y;
320     result.w = v3.z;
321     return result;
322 }
323
324 bool operator==<T:Equatable>(vec4<T> a, vec4<T> b)
325 {
326     return a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w;
327 }
328
329 thread T^ operator&[]<T>(thread vec4<T>^ foo, uint index)
330 {
331     if (index == 0)
332         return &foo->x;
333     if (index == 1)
334         return &foo->y;
335     if (index == 2)
336         return &foo->z;
337     if (index == 3)
338         return &foo->w;
339     trap;
340 }
341
342 native thread T^ operator&[]<T>(thread T[], uint);
343 native threadgroup T^ operator&[]<T:Primitive>(threadgroup T[], uint);
344 native device T^ operator&[]<T:Primitive>(device T[], uint);
345 native constant T^ operator&[]<T:Primitive>(constant T[], uint);
346
347 native uint operator.length<T>(thread T[]);
348 native uint operator.length<T:Primitive>(threadgroup T[]);
349 native uint operator.length<T:Primitive>(device T[]);
350 native uint operator.length<T:Primitive>(constant T[]);
351
352 uint operator.length<T, uint length>(T[length])
353 {
354     return length;
355 }
356 `;