1 //
2 // Copyright (c) 2002-2015 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 
194         case EOpFloatBitsToInt:
195             return "floatBitsToInt";
196         case EOpFloatBitsToUint:
197             return "floatBitsToUint";
198         case EOpIntBitsToFloat:
199             return "intBitsToFloat";
200         case EOpUintBitsToFloat:
201             return "uintBitsToFloat";
202 
203         case EOpFrexp:
204             return "frexp";
205         case EOpLdexp:
206             return "ldexp";
207 
208         case EOpPackSnorm2x16:
209             return "packSnorm2x16";
210         case EOpPackUnorm2x16:
211             return "packUnorm2x16";
212         case EOpPackHalf2x16:
213             return "packHalf2x16";
214         case EOpUnpackSnorm2x16:
215             return "unpackSnorm2x16";
216         case EOpUnpackUnorm2x16:
217             return "unpackUnorm2x16";
218         case EOpUnpackHalf2x16:
219             return "unpackHalf2x16";
220 
221         case EOpPackUnorm4x8:
222             return "packUnorm4x8";
223         case EOpPackSnorm4x8:
224             return "packSnorm4x8";
225         case EOpUnpackUnorm4x8:
226             return "unpackUnorm4x8";
227         case EOpUnpackSnorm4x8:
228             return "unpackSnorm4x8";
229 
230         case EOpLength:
231             return "length";
232         case EOpDistance:
233             return "distance";
234         case EOpDot:
235             return "dot";
236         case EOpCross:
237             return "cross";
238         case EOpNormalize:
239             return "normalize";
240         case EOpFaceforward:
241             return "faceforward";
242         case EOpReflect:
243             return "reflect";
244         case EOpRefract:
245             return "refract";
246 
247         case EOpDFdx:
248             return "dFdx";
249         case EOpDFdy:
250             return "dFdy";
251         case EOpFwidth:
252             return "fwidth";
253 
254         case EOpMulMatrixComponentWise:
255             return "matrixCompMult";
256         case EOpOuterProduct:
257             return "outerProduct";
258         case EOpTranspose:
259             return "transpose";
260         case EOpDeterminant:
261             return "determinant";
262         case EOpInverse:
263             return "inverse";
264 
265         case EOpAny:
266             return "any";
267         case EOpAll:
268             return "all";
269         case EOpLogicalNotComponentWise:
270             return "not";
271 
272         case EOpBitfieldExtract:
273             return "bitfieldExtract";
274         case EOpBitfieldInsert:
275             return "bitfieldInsert";
276         case EOpBitfieldReverse:
277             return "bitfieldReverse";
278         case EOpBitCount:
279             return "bitCount";
280         case EOpFindLSB:
281             return "findLSB";
282         case EOpFindMSB:
283             return "findMSB";
284         case EOpUaddCarry:
285             return "uaddCarry";
286         case EOpUsubBorrow:
287             return "usubBorrow";
288         case EOpUmulExtended:
289             return "umulExtended";
290         case EOpImulExtended:
291             return "imulExtended";
292 
293         case EOpKill:
294             return "kill";
295         case EOpReturn:
296             return "return";
297         case EOpBreak:
298             return "break";
299         case EOpContinue:
300             return "continue";
301 
302         case EOpAssign:
303             return "=";
304         case EOpInitialize:
305             return "=";
306         case EOpAddAssign:
307             return "+=";
308         case EOpSubAssign:
309             return "-=";
310 
311         // Fall-through.
312         case EOpMulAssign:
313         case EOpVectorTimesMatrixAssign:
314         case EOpVectorTimesScalarAssign:
315         case EOpMatrixTimesScalarAssign:
316         case EOpMatrixTimesMatrixAssign:
317             return "*=";
318 
319         case EOpDivAssign:
320             return "/=";
321         case EOpIModAssign:
322             return "%=";
323         case EOpBitShiftLeftAssign:
324             return "<<=";
325         case EOpBitShiftRightAssign:
326             return ">>=";
327         case EOpBitwiseAndAssign:
328             return "&=";
329         case EOpBitwiseXorAssign:
330             return "^=";
331         case EOpBitwiseOrAssign:
332             return "|=";
333         case EOpBarrier:
334             return "barrier";
335         case EOpMemoryBarrier:
336             return "memoryBarrier";
337         case EOpMemoryBarrierAtomicCounter:
338             return "memoryBarrierAtomicCounter";
339         case EOpMemoryBarrierBuffer:
340             return "memoryBarrierBuffer";
341         case EOpMemoryBarrierImage:
342             return "memoryBarrierImage";
343         case EOpMemoryBarrierShared:
344             return "memoryBarrierShared";
345         case EOpGroupMemoryBarrier:
346             return "groupMemoryBarrier";
347 
348         case EOpEmitVertex:
349             return "EmitVertex";
350         case EOpEndPrimitive:
351             return "EndPrimitive";
352         default:
353             break;
354     }
355     return "";
356 }
357 
IsAssignment(TOperator op)358 bool IsAssignment(TOperator op)
359 {
360     switch (op)
361     {
362         case EOpPostIncrement:
363         case EOpPostDecrement:
364         case EOpPreIncrement:
365         case EOpPreDecrement:
366         case EOpAssign:
367         case EOpAddAssign:
368         case EOpSubAssign:
369         case EOpMulAssign:
370         case EOpVectorTimesMatrixAssign:
371         case EOpVectorTimesScalarAssign:
372         case EOpMatrixTimesScalarAssign:
373         case EOpMatrixTimesMatrixAssign:
374         case EOpDivAssign:
375         case EOpIModAssign:
376         case EOpBitShiftLeftAssign:
377         case EOpBitShiftRightAssign:
378         case EOpBitwiseAndAssign:
379         case EOpBitwiseXorAssign:
380         case EOpBitwiseOrAssign:
381             return true;
382         default:
383             return false;
384     }
385 }