1 //
2 // Copyright 2002 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 
7 #include "compiler/translator/Operator.h"
8 
GetOperatorString(TOperator op)9 const char *GetOperatorString(TOperator op)
10 {
11     switch (op)
12     {
13             // Note: EOpNull and EOpCall* can't be handled here.
14 
15         case EOpNegative:
16             return "-";
17         case EOpPositive:
18             return "+";
19         case EOpLogicalNot:
20             return "!";
21         case EOpBitwiseNot:
22             return "~";
23 
24         case EOpPostIncrement:
25             return "++";
26         case EOpPostDecrement:
27             return "--";
28         case EOpPreIncrement:
29             return "++";
30         case EOpPreDecrement:
31             return "--";
32 
33         case EOpArrayLength:
34             return ".length()";
35 
36         case EOpAdd:
37             return "+";
38         case EOpSub:
39             return "-";
40         case EOpMul:
41             return "*";
42         case EOpDiv:
43             return "/";
44         case EOpIMod:
45             return "%";
46 
47         case EOpEqual:
48             return "==";
49         case EOpNotEqual:
50             return "!=";
51         case EOpLessThan:
52             return "<";
53         case EOpGreaterThan:
54             return ">";
55         case EOpLessThanEqual:
56             return "<=";
57         case EOpGreaterThanEqual:
58             return ">=";
59 
60         case EOpEqualComponentWise:
61             return "equal";
62         case EOpNotEqualComponentWise:
63             return "notEqual";
64         case EOpLessThanComponentWise:
65             return "lessThan";
66         case EOpGreaterThanComponentWise:
67             return "greaterThan";
68         case EOpLessThanEqualComponentWise:
69             return "lessThanEqual";
70         case EOpGreaterThanEqualComponentWise:
71             return "greaterThanEqual";
72 
73         case EOpComma:
74             return ",";
75 
76         // Fall-through.
77         case EOpVectorTimesScalar:
78         case EOpVectorTimesMatrix:
79         case EOpMatrixTimesVector:
80         case EOpMatrixTimesScalar:
81         case EOpMatrixTimesMatrix:
82             return "*";
83 
84         case EOpLogicalOr:
85             return "||";
86         case EOpLogicalXor:
87             return "^^";
88         case EOpLogicalAnd:
89             return "&&";
90 
91         case EOpBitShiftLeft:
92             return "<<";
93         case EOpBitShiftRight:
94             return ">>";
95 
96         case EOpBitwiseAnd:
97             return "&";
98         case EOpBitwiseXor:
99             return "^";
100         case EOpBitwiseOr:
101             return "|";
102 
103         // Fall-through.
104         case EOpIndexDirect:
105         case EOpIndexIndirect:
106             return "[]";
107 
108         case EOpIndexDirectStruct:
109         case EOpIndexDirectInterfaceBlock:
110             return ".";
111 
112         case EOpRadians:
113             return "radians";
114         case EOpDegrees:
115             return "degrees";
116         case EOpSin:
117             return "sin";
118         case EOpCos:
119             return "cos";
120         case EOpTan:
121             return "tan";
122         case EOpAsin:
123             return "asin";
124         case EOpAcos:
125             return "acos";
126         case EOpAtan:
127             return "atan";
128 
129         case EOpSinh:
130             return "sinh";
131         case EOpCosh:
132             return "cosh";
133         case EOpTanh:
134             return "tanh";
135         case EOpAsinh:
136             return "asinh";
137         case EOpAcosh:
138             return "acosh";
139         case EOpAtanh:
140             return "atanh";
141 
142         case EOpPow:
143             return "pow";
144         case EOpExp:
145             return "exp";
146         case EOpLog:
147             return "log";
148         case EOpExp2:
149             return "exp2";
150         case EOpLog2:
151             return "log2";
152         case EOpSqrt:
153             return "sqrt";
154         case EOpInversesqrt:
155             return "inversesqrt";
156 
157         case EOpAbs:
158             return "abs";
159         case EOpSign:
160             return "sign";
161         case EOpFloor:
162             return "floor";
163         case EOpTrunc:
164             return "trunc";
165         case EOpRound:
166             return "round";
167         case EOpRoundEven:
168             return "roundEven";
169         case EOpCeil:
170             return "ceil";
171         case EOpFract:
172             return "fract";
173         case EOpMod:
174             return "mod";
175         case EOpModf:
176             return "modf";
177         case EOpMin:
178             return "min";
179         case EOpMax:
180             return "max";
181         case EOpClamp:
182             return "clamp";
183         case EOpMix:
184             return "mix";
185         case EOpStep:
186             return "step";
187         case EOpSmoothstep:
188             return "smoothstep";
189         case EOpIsnan:
190             return "isnan";
191         case EOpIsinf:
192             return "isinf";
193         case EOpFma:
194             return "fma";
195 
196         case EOpFloatBitsToInt:
197             return "floatBitsToInt";
198         case EOpFloatBitsToUint:
199             return "floatBitsToUint";
200         case EOpIntBitsToFloat:
201             return "intBitsToFloat";
202         case EOpUintBitsToFloat:
203             return "uintBitsToFloat";
204 
205         case EOpFrexp:
206             return "frexp";
207         case EOpLdexp:
208             return "ldexp";
209 
210         case EOpPackSnorm2x16:
211             return "packSnorm2x16";
212         case EOpPackUnorm2x16:
213             return "packUnorm2x16";
214         case EOpPackHalf2x16:
215             return "packHalf2x16";
216         case EOpUnpackSnorm2x16:
217             return "unpackSnorm2x16";
218         case EOpUnpackUnorm2x16:
219             return "unpackUnorm2x16";
220         case EOpUnpackHalf2x16:
221             return "unpackHalf2x16";
222 
223         case EOpPackUnorm4x8:
224             return "packUnorm4x8";
225         case EOpPackSnorm4x8:
226             return "packSnorm4x8";
227         case EOpUnpackUnorm4x8:
228             return "unpackUnorm4x8";
229         case EOpUnpackSnorm4x8:
230             return "unpackSnorm4x8";
231 
232         case EOpLength:
233             return "length";
234         case EOpDistance:
235             return "distance";
236         case EOpDot:
237             return "dot";
238         case EOpCross:
239             return "cross";
240         case EOpNormalize:
241             return "normalize";
242         case EOpFaceforward:
243             return "faceforward";
244         case EOpReflect:
245             return "reflect";
246         case EOpRefract:
247             return "refract";
248 
249         case EOpDFdx:
250             return "dFdx";
251         case EOpDFdy:
252             return "dFdy";
253         case EOpFwidth:
254             return "fwidth";
255 
256         case EOpMulMatrixComponentWise:
257             return "matrixCompMult";
258         case EOpOuterProduct:
259             return "outerProduct";
260         case EOpTranspose:
261             return "transpose";
262         case EOpDeterminant:
263             return "determinant";
264         case EOpInverse:
265             return "inverse";
266 
267         case EOpAny:
268             return "any";
269         case EOpAll:
270             return "all";
271         case EOpLogicalNotComponentWise:
272             return "not";
273 
274         case EOpBitfieldExtract:
275             return "bitfieldExtract";
276         case EOpBitfieldInsert:
277             return "bitfieldInsert";
278         case EOpBitfieldReverse:
279             return "bitfieldReverse";
280         case EOpBitCount:
281             return "bitCount";
282         case EOpFindLSB:
283             return "findLSB";
284         case EOpFindMSB:
285             return "findMSB";
286         case EOpUaddCarry:
287             return "uaddCarry";
288         case EOpUsubBorrow:
289             return "usubBorrow";
290         case EOpUmulExtended:
291             return "umulExtended";
292         case EOpImulExtended:
293             return "imulExtended";
294 
295         case EOpKill:
296             return "kill";
297         case EOpReturn:
298             return "return";
299         case EOpBreak:
300             return "break";
301         case EOpContinue:
302             return "continue";
303 
304         case EOpAssign:
305             return "=";
306         case EOpInitialize:
307             return "=";
308         case EOpAddAssign:
309             return "+=";
310         case EOpSubAssign:
311             return "-=";
312 
313         // Fall-through.
314         case EOpMulAssign:
315         case EOpVectorTimesMatrixAssign:
316         case EOpVectorTimesScalarAssign:
317         case EOpMatrixTimesScalarAssign:
318         case EOpMatrixTimesMatrixAssign:
319             return "*=";
320 
321         case EOpDivAssign:
322             return "/=";
323         case EOpIModAssign:
324             return "%=";
325         case EOpBitShiftLeftAssign:
326             return "<<=";
327         case EOpBitShiftRightAssign:
328             return ">>=";
329         case EOpBitwiseAndAssign:
330             return "&=";
331         case EOpBitwiseXorAssign:
332             return "^=";
333         case EOpBitwiseOrAssign:
334             return "|=";
335         case EOpBarrier:
336             return "barrier";
337         case EOpMemoryBarrier:
338             return "memoryBarrier";
339         case EOpMemoryBarrierAtomicCounter:
340             return "memoryBarrierAtomicCounter";
341         case EOpMemoryBarrierBuffer:
342             return "memoryBarrierBuffer";
343         case EOpMemoryBarrierImage:
344             return "memoryBarrierImage";
345         case EOpMemoryBarrierShared:
346             return "memoryBarrierShared";
347         case EOpGroupMemoryBarrier:
348             return "groupMemoryBarrier";
349 
350         case EOpAtomicAdd:
351             return "atomicAdd";
352         case EOpAtomicMin:
353             return "atomicMin";
354         case EOpAtomicMax:
355             return "atomicMax";
356         case EOpAtomicAnd:
357             return "atomicAnd";
358         case EOpAtomicOr:
359             return "atomicOr";
360         case EOpAtomicXor:
361             return "atomicXor";
362         case EOpAtomicExchange:
363             return "atomicExchange";
364         case EOpAtomicCompSwap:
365             return "atomicCompSwap";
366 
367         case EOpEmitVertex:
368             return "EmitVertex";
369         case EOpEndPrimitive:
370             return "EndPrimitive";
371         default:
372             break;
373     }
374     return "";
375 }
376 
IsAssignment(TOperator op)377 bool IsAssignment(TOperator op)
378 {
379     switch (op)
380     {
381         case EOpPostIncrement:
382         case EOpPostDecrement:
383         case EOpPreIncrement:
384         case EOpPreDecrement:
385         case EOpAssign:
386         case EOpAddAssign:
387         case EOpSubAssign:
388         case EOpMulAssign:
389         case EOpVectorTimesMatrixAssign:
390         case EOpVectorTimesScalarAssign:
391         case EOpMatrixTimesScalarAssign:
392         case EOpMatrixTimesMatrixAssign:
393         case EOpDivAssign:
394         case EOpIModAssign:
395         case EOpBitShiftLeftAssign:
396         case EOpBitShiftRightAssign:
397         case EOpBitwiseAndAssign:
398         case EOpBitwiseXorAssign:
399         case EOpBitwiseOrAssign:
400             return true;
401         default:
402             return false;
403     }
404 }
405 
IsAtomicFunction(TOperator op)406 bool IsAtomicFunction(TOperator op)
407 {
408     switch (op)
409     {
410         case EOpAtomicAdd:
411         case EOpAtomicMin:
412         case EOpAtomicMax:
413         case EOpAtomicAnd:
414         case EOpAtomicOr:
415         case EOpAtomicXor:
416         case EOpAtomicExchange:
417         case EOpAtomicCompSwap:
418             return true;
419         default:
420             return false;
421     }
422 }
423