1    switch (this->operation) {
2    case ir_unop_bit_not:
3       for (unsigned c = 0; c < op[0]->type->components(); c++) {
4          switch (op[0]->type->base_type) {
5          case GLSL_TYPE_UINT:
6             data.u[c] = ~ op[0]->value.u[c];
7             break;
8          case GLSL_TYPE_INT:
9             data.i[c] = ~ op[0]->value.i[c];
10             break;
11          case GLSL_TYPE_UINT64:
12             data.u64[c] = ~ op[0]->value.u64[c];
13             break;
14          case GLSL_TYPE_INT64:
15             data.i64[c] = ~ op[0]->value.i64[c];
16             break;
17          default:
18             unreachable("invalid type");
19          }
20       }
21       break;
22 
23    case ir_unop_logic_not:
24       for (unsigned c = 0; c < op[0]->type->components(); c++) {
25          switch (op[0]->type->base_type) {
26          case GLSL_TYPE_BOOL:
27             data.b[c] = !op[0]->value.b[c];
28             break;
29          default:
30             unreachable("invalid type");
31          }
32       }
33       break;
34 
35    case ir_unop_neg:
36       for (unsigned c = 0; c < op[0]->type->components(); c++) {
37          switch (op[0]->type->base_type) {
38          case GLSL_TYPE_UINT:
39             data.u[c] = -((int) op[0]->value.u[c]);
40             break;
41          case GLSL_TYPE_INT:
42             data.i[c] = -op[0]->value.i[c];
43             break;
44          case GLSL_TYPE_FLOAT:
45             data.f[c] = -op[0]->value.f[c];
46             break;
47          case GLSL_TYPE_DOUBLE:
48             data.d[c] = -op[0]->value.d[c];
49             break;
50          case GLSL_TYPE_UINT64:
51             data.u64[c] = -((int64_t) op[0]->value.u64[c]);
52             break;
53          case GLSL_TYPE_INT64:
54             data.i64[c] = -op[0]->value.i64[c];
55             break;
56          default:
57             unreachable("invalid type");
58          }
59       }
60       break;
61 
62    case ir_unop_abs:
63       for (unsigned c = 0; c < op[0]->type->components(); c++) {
64          switch (op[0]->type->base_type) {
65          case GLSL_TYPE_INT:
66             data.i[c] = op[0]->value.i[c] < 0 ? -op[0]->value.i[c] : op[0]->value.i[c];
67             break;
68          case GLSL_TYPE_FLOAT:
69             data.f[c] = fabsf(op[0]->value.f[c]);
70             break;
71          case GLSL_TYPE_DOUBLE:
72             data.d[c] = fabs(op[0]->value.d[c]);
73             break;
74          case GLSL_TYPE_INT64:
75             data.i64[c] = op[0]->value.i64[c] < 0 ? -op[0]->value.i64[c] : op[0]->value.i64[c];
76             break;
77          default:
78             unreachable("invalid type");
79          }
80       }
81       break;
82 
83    case ir_unop_sign:
84       for (unsigned c = 0; c < op[0]->type->components(); c++) {
85          switch (op[0]->type->base_type) {
86          case GLSL_TYPE_INT:
87             data.i[c] = (op[0]->value.i[c] > 0) - (op[0]->value.i[c] < 0);
88             break;
89          case GLSL_TYPE_FLOAT:
90             data.f[c] = float((op[0]->value.f[c] > 0.0F) - (op[0]->value.f[c] < 0.0F));
91             break;
92          case GLSL_TYPE_DOUBLE:
93             data.d[c] = double((op[0]->value.d[c] > 0.0) - (op[0]->value.d[c] < 0.0));
94             break;
95          case GLSL_TYPE_INT64:
96             data.i64[c] = (op[0]->value.i64[c] > 0) - (op[0]->value.i64[c] < 0);
97             break;
98          default:
99             unreachable("invalid type");
100          }
101       }
102       break;
103 
104    case ir_unop_rcp:
105       for (unsigned c = 0; c < op[0]->type->components(); c++) {
106          switch (op[0]->type->base_type) {
107          case GLSL_TYPE_FLOAT:
108             data.f[c] = 1.0F / op[0]->value.f[c];
109             break;
110          case GLSL_TYPE_DOUBLE:
111             data.d[c] = 1.0 / op[0]->value.d[c];
112             break;
113          default:
114             unreachable("invalid type");
115          }
116       }
117       break;
118 
119    case ir_unop_rsq:
120       for (unsigned c = 0; c < op[0]->type->components(); c++) {
121          switch (op[0]->type->base_type) {
122          case GLSL_TYPE_FLOAT:
123             data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]);
124             break;
125          case GLSL_TYPE_DOUBLE:
126             data.d[c] = 1.0 / sqrt(op[0]->value.d[c]);
127             break;
128          default:
129             unreachable("invalid type");
130          }
131       }
132       break;
133 
134    case ir_unop_sqrt:
135       for (unsigned c = 0; c < op[0]->type->components(); c++) {
136          switch (op[0]->type->base_type) {
137          case GLSL_TYPE_FLOAT:
138             data.f[c] = sqrtf(op[0]->value.f[c]);
139             break;
140          case GLSL_TYPE_DOUBLE:
141             data.d[c] = sqrt(op[0]->value.d[c]);
142             break;
143          default:
144             unreachable("invalid type");
145          }
146       }
147       break;
148 
149    case ir_unop_exp:
150       for (unsigned c = 0; c < op[0]->type->components(); c++) {
151          switch (op[0]->type->base_type) {
152          case GLSL_TYPE_FLOAT:
153             data.f[c] = expf(op[0]->value.f[c]);
154             break;
155          default:
156             unreachable("invalid type");
157          }
158       }
159       break;
160 
161    case ir_unop_log:
162       for (unsigned c = 0; c < op[0]->type->components(); c++) {
163          switch (op[0]->type->base_type) {
164          case GLSL_TYPE_FLOAT:
165             data.f[c] = logf(op[0]->value.f[c]);
166             break;
167          default:
168             unreachable("invalid type");
169          }
170       }
171       break;
172 
173    case ir_unop_exp2:
174       for (unsigned c = 0; c < op[0]->type->components(); c++) {
175          switch (op[0]->type->base_type) {
176          case GLSL_TYPE_FLOAT:
177             data.f[c] = exp2f(op[0]->value.f[c]);
178             break;
179          default:
180             unreachable("invalid type");
181          }
182       }
183       break;
184 
185    case ir_unop_log2:
186       for (unsigned c = 0; c < op[0]->type->components(); c++) {
187          switch (op[0]->type->base_type) {
188          case GLSL_TYPE_FLOAT:
189             data.f[c] = log2f(op[0]->value.f[c]);
190             break;
191          default:
192             unreachable("invalid type");
193          }
194       }
195       break;
196 
197    case ir_unop_f2i:
198       for (unsigned c = 0; c < op[0]->type->components(); c++) {
199          switch (op[0]->type->base_type) {
200          case GLSL_TYPE_FLOAT:
201             data.i[c] = (int) op[0]->value.f[c];
202             break;
203          default:
204             unreachable("invalid type");
205          }
206       }
207       break;
208 
209    case ir_unop_f2u:
210       for (unsigned c = 0; c < op[0]->type->components(); c++) {
211          switch (op[0]->type->base_type) {
212          case GLSL_TYPE_FLOAT:
213             data.u[c] = (unsigned) op[0]->value.f[c];
214             break;
215          default:
216             unreachable("invalid type");
217          }
218       }
219       break;
220 
221    case ir_unop_i2f:
222       for (unsigned c = 0; c < op[0]->type->components(); c++) {
223          switch (op[0]->type->base_type) {
224          case GLSL_TYPE_INT:
225             data.f[c] = (float) op[0]->value.i[c];
226             break;
227          default:
228             unreachable("invalid type");
229          }
230       }
231       break;
232 
233    case ir_unop_f2b:
234       for (unsigned c = 0; c < op[0]->type->components(); c++) {
235          switch (op[0]->type->base_type) {
236          case GLSL_TYPE_FLOAT:
237             data.b[c] = op[0]->value.f[c] != 0.0F ? true : false;
238             break;
239          default:
240             unreachable("invalid type");
241          }
242       }
243       break;
244 
245    case ir_unop_b2f:
246       for (unsigned c = 0; c < op[0]->type->components(); c++) {
247          switch (op[0]->type->base_type) {
248          case GLSL_TYPE_BOOL:
249             data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F;
250             break;
251          default:
252             unreachable("invalid type");
253          }
254       }
255       break;
256 
257    case ir_unop_b2f16:
258       for (unsigned c = 0; c < op[0]->type->components(); c++) {
259          switch (op[0]->type->base_type) {
260          case GLSL_TYPE_BOOL:
261             data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F;
262             break;
263          default:
264             unreachable("invalid type");
265          }
266       }
267       break;
268 
269    case ir_unop_i2b:
270       for (unsigned c = 0; c < op[0]->type->components(); c++) {
271          switch (op[0]->type->base_type) {
272          case GLSL_TYPE_UINT:
273             data.b[c] = op[0]->value.u[c] ? true : false;
274             break;
275          case GLSL_TYPE_INT:
276             data.b[c] = op[0]->value.i[c] ? true : false;
277             break;
278          default:
279             unreachable("invalid type");
280          }
281       }
282       break;
283 
284    case ir_unop_b2i:
285       for (unsigned c = 0; c < op[0]->type->components(); c++) {
286          switch (op[0]->type->base_type) {
287          case GLSL_TYPE_BOOL:
288             data.i[c] = op[0]->value.b[c] ? 1 : 0;
289             break;
290          default:
291             unreachable("invalid type");
292          }
293       }
294       break;
295 
296    case ir_unop_u2f:
297       for (unsigned c = 0; c < op[0]->type->components(); c++) {
298          switch (op[0]->type->base_type) {
299          case GLSL_TYPE_UINT:
300             data.f[c] = (float) op[0]->value.u[c];
301             break;
302          default:
303             unreachable("invalid type");
304          }
305       }
306       break;
307 
308    case ir_unop_i2u:
309       for (unsigned c = 0; c < op[0]->type->components(); c++) {
310          switch (op[0]->type->base_type) {
311          case GLSL_TYPE_INT:
312             data.u[c] = op[0]->value.i[c];
313             break;
314          default:
315             unreachable("invalid type");
316          }
317       }
318       break;
319 
320    case ir_unop_u2i:
321       for (unsigned c = 0; c < op[0]->type->components(); c++) {
322          switch (op[0]->type->base_type) {
323          case GLSL_TYPE_UINT:
324             data.i[c] = op[0]->value.u[c];
325             break;
326          default:
327             unreachable("invalid type");
328          }
329       }
330       break;
331 
332    case ir_unop_d2f:
333       for (unsigned c = 0; c < op[0]->type->components(); c++) {
334          switch (op[0]->type->base_type) {
335          case GLSL_TYPE_DOUBLE:
336             data.f[c] = op[0]->value.d[c];
337             break;
338          default:
339             unreachable("invalid type");
340          }
341       }
342       break;
343 
344    case ir_unop_f2d:
345       for (unsigned c = 0; c < op[0]->type->components(); c++) {
346          switch (op[0]->type->base_type) {
347          case GLSL_TYPE_FLOAT:
348             data.d[c] = op[0]->value.f[c];
349             break;
350          default:
351             unreachable("invalid type");
352          }
353       }
354       break;
355 
356    case ir_unop_f2f16:
357       for (unsigned c = 0; c < op[0]->type->components(); c++) {
358          switch (op[0]->type->base_type) {
359          case GLSL_TYPE_FLOAT:
360             data.f[c] = op[0]->value.f[c];
361             break;
362          default:
363             unreachable("invalid type");
364          }
365       }
366       break;
367 
368    case ir_unop_f2fmp:
369       for (unsigned c = 0; c < op[0]->type->components(); c++) {
370          switch (op[0]->type->base_type) {
371          case GLSL_TYPE_FLOAT:
372             data.f[c] = op[0]->value.f[c];
373             break;
374          default:
375             unreachable("invalid type");
376          }
377       }
378       break;
379 
380    case ir_unop_f162f:
381       for (unsigned c = 0; c < op[0]->type->components(); c++) {
382          switch (op[0]->type->base_type) {
383          case GLSL_TYPE_FLOAT:
384             data.f[c] = op[0]->value.f[c];
385             break;
386          default:
387             unreachable("invalid type");
388          }
389       }
390       break;
391 
392    case ir_unop_d2i:
393       for (unsigned c = 0; c < op[0]->type->components(); c++) {
394          switch (op[0]->type->base_type) {
395          case GLSL_TYPE_DOUBLE:
396             data.i[c] = op[0]->value.d[c];
397             break;
398          default:
399             unreachable("invalid type");
400          }
401       }
402       break;
403 
404    case ir_unop_i2d:
405       for (unsigned c = 0; c < op[0]->type->components(); c++) {
406          switch (op[0]->type->base_type) {
407          case GLSL_TYPE_INT:
408             data.d[c] = op[0]->value.i[c];
409             break;
410          default:
411             unreachable("invalid type");
412          }
413       }
414       break;
415 
416    case ir_unop_d2u:
417       for (unsigned c = 0; c < op[0]->type->components(); c++) {
418          switch (op[0]->type->base_type) {
419          case GLSL_TYPE_DOUBLE:
420             data.u[c] = op[0]->value.d[c];
421             break;
422          default:
423             unreachable("invalid type");
424          }
425       }
426       break;
427 
428    case ir_unop_u2d:
429       for (unsigned c = 0; c < op[0]->type->components(); c++) {
430          switch (op[0]->type->base_type) {
431          case GLSL_TYPE_UINT:
432             data.d[c] = op[0]->value.u[c];
433             break;
434          default:
435             unreachable("invalid type");
436          }
437       }
438       break;
439 
440    case ir_unop_d2b:
441       for (unsigned c = 0; c < op[0]->type->components(); c++) {
442          switch (op[0]->type->base_type) {
443          case GLSL_TYPE_DOUBLE:
444             data.b[c] = op[0]->value.d[c] != 0.0;
445             break;
446          default:
447             unreachable("invalid type");
448          }
449       }
450       break;
451 
452    case ir_unop_f162b:
453       for (unsigned c = 0; c < op[0]->type->components(); c++) {
454          switch (op[0]->type->base_type) {
455          case GLSL_TYPE_FLOAT:
456             data.b[c] = op[0]->value.f[c] != 0.0;
457             break;
458          default:
459             unreachable("invalid type");
460          }
461       }
462       break;
463 
464    case ir_unop_bitcast_i2f:
465       for (unsigned c = 0; c < op[0]->type->components(); c++) {
466          switch (op[0]->type->base_type) {
467          case GLSL_TYPE_INT:
468             data.f[c] = bitcast_u2f(op[0]->value.i[c]);
469             break;
470          default:
471             unreachable("invalid type");
472          }
473       }
474       break;
475 
476    case ir_unop_bitcast_f2i:
477       for (unsigned c = 0; c < op[0]->type->components(); c++) {
478          switch (op[0]->type->base_type) {
479          case GLSL_TYPE_FLOAT:
480             data.i[c] = bitcast_f2u(op[0]->value.f[c]);
481             break;
482          default:
483             unreachable("invalid type");
484          }
485       }
486       break;
487 
488    case ir_unop_bitcast_u2f:
489       for (unsigned c = 0; c < op[0]->type->components(); c++) {
490          switch (op[0]->type->base_type) {
491          case GLSL_TYPE_UINT:
492             data.f[c] = bitcast_u2f(op[0]->value.u[c]);
493             break;
494          default:
495             unreachable("invalid type");
496          }
497       }
498       break;
499 
500    case ir_unop_bitcast_f2u:
501       for (unsigned c = 0; c < op[0]->type->components(); c++) {
502          switch (op[0]->type->base_type) {
503          case GLSL_TYPE_FLOAT:
504             data.u[c] = bitcast_f2u(op[0]->value.f[c]);
505             break;
506          default:
507             unreachable("invalid type");
508          }
509       }
510       break;
511 
512    case ir_unop_bitcast_u642d:
513       for (unsigned c = 0; c < op[0]->type->components(); c++) {
514          switch (op[0]->type->base_type) {
515          case GLSL_TYPE_UINT64:
516             data.d[c] = bitcast_u642d(op[0]->value.u64[c]);
517             break;
518          default:
519             unreachable("invalid type");
520          }
521       }
522       break;
523 
524    case ir_unop_bitcast_i642d:
525       for (unsigned c = 0; c < op[0]->type->components(); c++) {
526          switch (op[0]->type->base_type) {
527          case GLSL_TYPE_INT64:
528             data.d[c] = bitcast_i642d(op[0]->value.i64[c]);
529             break;
530          default:
531             unreachable("invalid type");
532          }
533       }
534       break;
535 
536    case ir_unop_bitcast_d2u64:
537       for (unsigned c = 0; c < op[0]->type->components(); c++) {
538          switch (op[0]->type->base_type) {
539          case GLSL_TYPE_DOUBLE:
540             data.u64[c] = bitcast_d2u64(op[0]->value.d[c]);
541             break;
542          default:
543             unreachable("invalid type");
544          }
545       }
546       break;
547 
548    case ir_unop_bitcast_d2i64:
549       for (unsigned c = 0; c < op[0]->type->components(); c++) {
550          switch (op[0]->type->base_type) {
551          case GLSL_TYPE_DOUBLE:
552             data.i64[c] = bitcast_d2i64(op[0]->value.d[c]);
553             break;
554          default:
555             unreachable("invalid type");
556          }
557       }
558       break;
559 
560    case ir_unop_i642i:
561       for (unsigned c = 0; c < op[0]->type->components(); c++) {
562          switch (op[0]->type->base_type) {
563          case GLSL_TYPE_INT64:
564             data.i[c] = op[0]->value.i64[c];
565             break;
566          default:
567             unreachable("invalid type");
568          }
569       }
570       break;
571 
572    case ir_unop_u642i:
573       for (unsigned c = 0; c < op[0]->type->components(); c++) {
574          switch (op[0]->type->base_type) {
575          case GLSL_TYPE_UINT64:
576             data.i[c] = op[0]->value.u64[c];
577             break;
578          default:
579             unreachable("invalid type");
580          }
581       }
582       break;
583 
584    case ir_unop_i642u:
585       for (unsigned c = 0; c < op[0]->type->components(); c++) {
586          switch (op[0]->type->base_type) {
587          case GLSL_TYPE_INT64:
588             data.u[c] = op[0]->value.i64[c];
589             break;
590          default:
591             unreachable("invalid type");
592          }
593       }
594       break;
595 
596    case ir_unop_u642u:
597       for (unsigned c = 0; c < op[0]->type->components(); c++) {
598          switch (op[0]->type->base_type) {
599          case GLSL_TYPE_UINT64:
600             data.u[c] = op[0]->value.u64[c];
601             break;
602          default:
603             unreachable("invalid type");
604          }
605       }
606       break;
607 
608    case ir_unop_i642b:
609       for (unsigned c = 0; c < op[0]->type->components(); c++) {
610          switch (op[0]->type->base_type) {
611          case GLSL_TYPE_INT64:
612             data.b[c] = op[0]->value.i64[c] != 0;
613             break;
614          default:
615             unreachable("invalid type");
616          }
617       }
618       break;
619 
620    case ir_unop_i642f:
621       for (unsigned c = 0; c < op[0]->type->components(); c++) {
622          switch (op[0]->type->base_type) {
623          case GLSL_TYPE_INT64:
624             data.f[c] = op[0]->value.i64[c];
625             break;
626          default:
627             unreachable("invalid type");
628          }
629       }
630       break;
631 
632    case ir_unop_u642f:
633       for (unsigned c = 0; c < op[0]->type->components(); c++) {
634          switch (op[0]->type->base_type) {
635          case GLSL_TYPE_UINT64:
636             data.f[c] = op[0]->value.u64[c];
637             break;
638          default:
639             unreachable("invalid type");
640          }
641       }
642       break;
643 
644    case ir_unop_i642d:
645       for (unsigned c = 0; c < op[0]->type->components(); c++) {
646          switch (op[0]->type->base_type) {
647          case GLSL_TYPE_INT64:
648             data.d[c] = op[0]->value.i64[c];
649             break;
650          default:
651             unreachable("invalid type");
652          }
653       }
654       break;
655 
656    case ir_unop_u642d:
657       for (unsigned c = 0; c < op[0]->type->components(); c++) {
658          switch (op[0]->type->base_type) {
659          case GLSL_TYPE_UINT64:
660             data.d[c] = op[0]->value.u64[c];
661             break;
662          default:
663             unreachable("invalid type");
664          }
665       }
666       break;
667 
668    case ir_unop_i2i64:
669       for (unsigned c = 0; c < op[0]->type->components(); c++) {
670          switch (op[0]->type->base_type) {
671          case GLSL_TYPE_INT:
672             data.i64[c] = op[0]->value.i[c];
673             break;
674          default:
675             unreachable("invalid type");
676          }
677       }
678       break;
679 
680    case ir_unop_u2i64:
681       for (unsigned c = 0; c < op[0]->type->components(); c++) {
682          switch (op[0]->type->base_type) {
683          case GLSL_TYPE_UINT:
684             data.i64[c] = op[0]->value.u[c];
685             break;
686          default:
687             unreachable("invalid type");
688          }
689       }
690       break;
691 
692    case ir_unop_b2i64:
693       for (unsigned c = 0; c < op[0]->type->components(); c++) {
694          switch (op[0]->type->base_type) {
695          case GLSL_TYPE_BOOL:
696             data.i64[c] = op[0]->value.b[c];
697             break;
698          default:
699             unreachable("invalid type");
700          }
701       }
702       break;
703 
704    case ir_unop_f2i64:
705       for (unsigned c = 0; c < op[0]->type->components(); c++) {
706          switch (op[0]->type->base_type) {
707          case GLSL_TYPE_FLOAT:
708             data.i64[c] = op[0]->value.f[c];
709             break;
710          default:
711             unreachable("invalid type");
712          }
713       }
714       break;
715 
716    case ir_unop_d2i64:
717       for (unsigned c = 0; c < op[0]->type->components(); c++) {
718          switch (op[0]->type->base_type) {
719          case GLSL_TYPE_DOUBLE:
720             data.i64[c] = op[0]->value.d[c];
721             break;
722          default:
723             unreachable("invalid type");
724          }
725       }
726       break;
727 
728    case ir_unop_i2u64:
729       for (unsigned c = 0; c < op[0]->type->components(); c++) {
730          switch (op[0]->type->base_type) {
731          case GLSL_TYPE_INT:
732             data.u64[c] = op[0]->value.i[c];
733             break;
734          default:
735             unreachable("invalid type");
736          }
737       }
738       break;
739 
740    case ir_unop_u2u64:
741       for (unsigned c = 0; c < op[0]->type->components(); c++) {
742          switch (op[0]->type->base_type) {
743          case GLSL_TYPE_UINT:
744             data.u64[c] = op[0]->value.u[c];
745             break;
746          default:
747             unreachable("invalid type");
748          }
749       }
750       break;
751 
752    case ir_unop_f2u64:
753       for (unsigned c = 0; c < op[0]->type->components(); c++) {
754          switch (op[0]->type->base_type) {
755          case GLSL_TYPE_FLOAT:
756             data.u64[c] = op[0]->value.f[c];
757             break;
758          default:
759             unreachable("invalid type");
760          }
761       }
762       break;
763 
764    case ir_unop_d2u64:
765       for (unsigned c = 0; c < op[0]->type->components(); c++) {
766          switch (op[0]->type->base_type) {
767          case GLSL_TYPE_DOUBLE:
768             data.u64[c] = op[0]->value.d[c];
769             break;
770          default:
771             unreachable("invalid type");
772          }
773       }
774       break;
775 
776    case ir_unop_u642i64:
777       for (unsigned c = 0; c < op[0]->type->components(); c++) {
778          switch (op[0]->type->base_type) {
779          case GLSL_TYPE_UINT64:
780             data.i64[c] = op[0]->value.u64[c];
781             break;
782          default:
783             unreachable("invalid type");
784          }
785       }
786       break;
787 
788    case ir_unop_i642u64:
789       for (unsigned c = 0; c < op[0]->type->components(); c++) {
790          switch (op[0]->type->base_type) {
791          case GLSL_TYPE_INT64:
792             data.u64[c] = op[0]->value.i64[c];
793             break;
794          default:
795             unreachable("invalid type");
796          }
797       }
798       break;
799 
800    case ir_unop_trunc:
801       for (unsigned c = 0; c < op[0]->type->components(); c++) {
802          switch (op[0]->type->base_type) {
803          case GLSL_TYPE_FLOAT:
804             data.f[c] = truncf(op[0]->value.f[c]);
805             break;
806          case GLSL_TYPE_DOUBLE:
807             data.d[c] = trunc(op[0]->value.d[c]);
808             break;
809          default:
810             unreachable("invalid type");
811          }
812       }
813       break;
814 
815    case ir_unop_ceil:
816       for (unsigned c = 0; c < op[0]->type->components(); c++) {
817          switch (op[0]->type->base_type) {
818          case GLSL_TYPE_FLOAT:
819             data.f[c] = ceilf(op[0]->value.f[c]);
820             break;
821          case GLSL_TYPE_DOUBLE:
822             data.d[c] = ceil(op[0]->value.d[c]);
823             break;
824          default:
825             unreachable("invalid type");
826          }
827       }
828       break;
829 
830    case ir_unop_floor:
831       for (unsigned c = 0; c < op[0]->type->components(); c++) {
832          switch (op[0]->type->base_type) {
833          case GLSL_TYPE_FLOAT:
834             data.f[c] = floorf(op[0]->value.f[c]);
835             break;
836          case GLSL_TYPE_DOUBLE:
837             data.d[c] = floor(op[0]->value.d[c]);
838             break;
839          default:
840             unreachable("invalid type");
841          }
842       }
843       break;
844 
845    case ir_unop_fract:
846       for (unsigned c = 0; c < op[0]->type->components(); c++) {
847          switch (op[0]->type->base_type) {
848          case GLSL_TYPE_FLOAT:
849             data.f[c] = op[0]->value.f[c] - floorf(op[0]->value.f[c]);
850             break;
851          case GLSL_TYPE_DOUBLE:
852             data.d[c] = op[0]->value.d[c] - floor(op[0]->value.d[c]);
853             break;
854          default:
855             unreachable("invalid type");
856          }
857       }
858       break;
859 
860    case ir_unop_round_even:
861       for (unsigned c = 0; c < op[0]->type->components(); c++) {
862          switch (op[0]->type->base_type) {
863          case GLSL_TYPE_FLOAT:
864             data.f[c] = _mesa_roundevenf(op[0]->value.f[c]);
865             break;
866          case GLSL_TYPE_DOUBLE:
867             data.d[c] = _mesa_roundeven(op[0]->value.d[c]);
868             break;
869          default:
870             unreachable("invalid type");
871          }
872       }
873       break;
874 
875    case ir_unop_sin:
876       for (unsigned c = 0; c < op[0]->type->components(); c++) {
877          switch (op[0]->type->base_type) {
878          case GLSL_TYPE_FLOAT:
879             data.f[c] = sinf(op[0]->value.f[c]);
880             break;
881          default:
882             unreachable("invalid type");
883          }
884       }
885       break;
886 
887    case ir_unop_cos:
888       for (unsigned c = 0; c < op[0]->type->components(); c++) {
889          switch (op[0]->type->base_type) {
890          case GLSL_TYPE_FLOAT:
891             data.f[c] = cosf(op[0]->value.f[c]);
892             break;
893          default:
894             unreachable("invalid type");
895          }
896       }
897       break;
898 
899    case ir_unop_atan:
900       for (unsigned c = 0; c < op[0]->type->components(); c++) {
901          switch (op[0]->type->base_type) {
902          case GLSL_TYPE_FLOAT:
903             data.f[c] = atan(op[0]->value.f[c]);
904             break;
905          default:
906             unreachable("invalid type");
907          }
908       }
909       break;
910 
911    case ir_unop_dFdx:
912       for (unsigned c = 0; c < op[0]->type->components(); c++) {
913          switch (op[0]->type->base_type) {
914          case GLSL_TYPE_FLOAT:
915             data.f[c] = 0.0f;
916             break;
917          default:
918             unreachable("invalid type");
919          }
920       }
921       break;
922 
923    case ir_unop_dFdx_coarse:
924       for (unsigned c = 0; c < op[0]->type->components(); c++) {
925          switch (op[0]->type->base_type) {
926          case GLSL_TYPE_FLOAT:
927             data.f[c] = 0.0f;
928             break;
929          default:
930             unreachable("invalid type");
931          }
932       }
933       break;
934 
935    case ir_unop_dFdx_fine:
936       for (unsigned c = 0; c < op[0]->type->components(); c++) {
937          switch (op[0]->type->base_type) {
938          case GLSL_TYPE_FLOAT:
939             data.f[c] = 0.0f;
940             break;
941          default:
942             unreachable("invalid type");
943          }
944       }
945       break;
946 
947    case ir_unop_dFdy:
948       for (unsigned c = 0; c < op[0]->type->components(); c++) {
949          switch (op[0]->type->base_type) {
950          case GLSL_TYPE_FLOAT:
951             data.f[c] = 0.0f;
952             break;
953          default:
954             unreachable("invalid type");
955          }
956       }
957       break;
958 
959    case ir_unop_dFdy_coarse:
960       for (unsigned c = 0; c < op[0]->type->components(); c++) {
961          switch (op[0]->type->base_type) {
962          case GLSL_TYPE_FLOAT:
963             data.f[c] = 0.0f;
964             break;
965          default:
966             unreachable("invalid type");
967          }
968       }
969       break;
970 
971    case ir_unop_dFdy_fine:
972       for (unsigned c = 0; c < op[0]->type->components(); c++) {
973          switch (op[0]->type->base_type) {
974          case GLSL_TYPE_FLOAT:
975             data.f[c] = 0.0f;
976             break;
977          default:
978             unreachable("invalid type");
979          }
980       }
981       break;
982 
983    case ir_unop_pack_snorm_2x16:
984       switch (op[0]->type->base_type) {
985       case GLSL_TYPE_FLOAT:
986          data.u[0] = pack_2x16(pack_snorm_1x16, op[0]->value.f[0], op[0]->value.f[1]);
987          break;
988       default:
989          unreachable("invalid type");
990       }
991       break;
992 
993    case ir_unop_pack_snorm_4x8:
994       switch (op[0]->type->base_type) {
995       case GLSL_TYPE_FLOAT:
996          data.u[0] = pack_4x8(pack_snorm_1x8, op[0]->value.f[0], op[0]->value.f[1], op[0]->value.f[2], op[0]->value.f[3]);
997          break;
998       default:
999          unreachable("invalid type");
1000       }
1001       break;
1002 
1003    case ir_unop_pack_unorm_2x16:
1004       switch (op[0]->type->base_type) {
1005       case GLSL_TYPE_FLOAT:
1006          data.u[0] = pack_2x16(pack_unorm_1x16, op[0]->value.f[0], op[0]->value.f[1]);
1007          break;
1008       default:
1009          unreachable("invalid type");
1010       }
1011       break;
1012 
1013    case ir_unop_pack_unorm_4x8:
1014       switch (op[0]->type->base_type) {
1015       case GLSL_TYPE_FLOAT:
1016          data.u[0] = pack_4x8(pack_unorm_1x8, op[0]->value.f[0], op[0]->value.f[1], op[0]->value.f[2], op[0]->value.f[3]);
1017          break;
1018       default:
1019          unreachable("invalid type");
1020       }
1021       break;
1022 
1023    case ir_unop_pack_half_2x16:
1024       switch (op[0]->type->base_type) {
1025       case GLSL_TYPE_FLOAT:
1026          data.u[0] = pack_2x16(pack_half_1x16, op[0]->value.f[0], op[0]->value.f[1]);
1027          break;
1028       default:
1029          unreachable("invalid type");
1030       }
1031       break;
1032 
1033    case ir_unop_unpack_snorm_2x16:
1034       unpack_2x16(unpack_snorm_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]);
1035       break;
1036 
1037    case ir_unop_unpack_snorm_4x8:
1038       unpack_4x8(unpack_snorm_1x8, op[0]->value.u[0], &data.f[0], &data.f[1], &data.f[2], &data.f[3]);
1039       break;
1040 
1041    case ir_unop_unpack_unorm_2x16:
1042       unpack_2x16(unpack_unorm_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]);
1043       break;
1044 
1045    case ir_unop_unpack_unorm_4x8:
1046       unpack_4x8(unpack_unorm_1x8, op[0]->value.u[0], &data.f[0], &data.f[1], &data.f[2], &data.f[3]);
1047       break;
1048 
1049    case ir_unop_unpack_half_2x16:
1050       unpack_2x16(unpack_half_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]);
1051       break;
1052 
1053    case ir_unop_bitfield_reverse:
1054       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1055          switch (op[0]->type->base_type) {
1056          case GLSL_TYPE_UINT:
1057             data.u[c] = bitfield_reverse(op[0]->value.u[c]);
1058             break;
1059          case GLSL_TYPE_INT:
1060             data.i[c] = bitfield_reverse(op[0]->value.i[c]);
1061             break;
1062          default:
1063             unreachable("invalid type");
1064          }
1065       }
1066       break;
1067 
1068    case ir_unop_bit_count:
1069       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1070          switch (op[0]->type->base_type) {
1071          case GLSL_TYPE_UINT:
1072             data.i[c] = util_bitcount(op[0]->value.u[c]);
1073             break;
1074          case GLSL_TYPE_INT:
1075             data.i[c] = util_bitcount(op[0]->value.i[c]);
1076             break;
1077          default:
1078             unreachable("invalid type");
1079          }
1080       }
1081       break;
1082 
1083    case ir_unop_find_msb:
1084       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1085          switch (op[0]->type->base_type) {
1086          case GLSL_TYPE_UINT:
1087             data.i[c] = find_msb_uint(op[0]->value.u[c]);
1088             break;
1089          case GLSL_TYPE_INT:
1090             data.i[c] = find_msb_int(op[0]->value.i[c]);
1091             break;
1092          default:
1093             unreachable("invalid type");
1094          }
1095       }
1096       break;
1097 
1098    case ir_unop_find_lsb:
1099       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1100          switch (op[0]->type->base_type) {
1101          case GLSL_TYPE_UINT:
1102             data.i[c] = find_msb_uint(op[0]->value.u[c] & -op[0]->value.u[c]);
1103             break;
1104          case GLSL_TYPE_INT:
1105             data.i[c] = find_msb_uint(op[0]->value.i[c] & -op[0]->value.i[c]);
1106             break;
1107          default:
1108             unreachable("invalid type");
1109          }
1110       }
1111       break;
1112 
1113    case ir_unop_clz:
1114       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1115          switch (op[0]->type->base_type) {
1116          case GLSL_TYPE_UINT:
1117             data.u[c] = (unsigned)(31 - find_msb_uint(op[0]->value.u[c]));
1118             break;
1119          default:
1120             unreachable("invalid type");
1121          }
1122       }
1123       break;
1124 
1125    case ir_unop_saturate:
1126       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1127          switch (op[0]->type->base_type) {
1128          case GLSL_TYPE_FLOAT:
1129             data.f[c] = CLAMP(op[0]->value.f[c], 0.0f, 1.0f);
1130             break;
1131          default:
1132             unreachable("invalid type");
1133          }
1134       }
1135       break;
1136 
1137    case ir_unop_pack_double_2x32:
1138       data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]);
1139       break;
1140 
1141    case ir_unop_unpack_double_2x32:
1142       unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]);
1143       break;
1144 
1145    case ir_unop_pack_sampler_2x32:
1146       data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]);
1147       break;
1148 
1149    case ir_unop_pack_image_2x32:
1150       data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]);
1151       break;
1152 
1153    case ir_unop_unpack_sampler_2x32:
1154       unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]);
1155       break;
1156 
1157    case ir_unop_unpack_image_2x32:
1158       unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]);
1159       break;
1160 
1161    case ir_unop_pack_int_2x32:
1162       data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]);
1163       break;
1164 
1165    case ir_unop_pack_uint_2x32:
1166       data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]);
1167       break;
1168 
1169    case ir_unop_unpack_int_2x32:
1170       unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]);
1171       break;
1172 
1173    case ir_unop_unpack_uint_2x32:
1174       unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]);
1175       break;
1176 
1177    case ir_binop_add:
1178       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1179       for (unsigned c = 0, c0 = 0, c1 = 0;
1180            c < components;
1181            c0 += c0_inc, c1 += c1_inc, c++) {
1182 
1183          switch (op[0]->type->base_type) {
1184          case GLSL_TYPE_UINT:
1185             data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1];
1186             break;
1187          case GLSL_TYPE_INT:
1188             data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1];
1189             break;
1190          case GLSL_TYPE_FLOAT:
1191             data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1];
1192             break;
1193          case GLSL_TYPE_DOUBLE:
1194             data.d[c] = op[0]->value.d[c0] + op[1]->value.d[c1];
1195             break;
1196          case GLSL_TYPE_UINT64:
1197             data.u64[c] = op[0]->value.u64[c0] + op[1]->value.u64[c1];
1198             break;
1199          case GLSL_TYPE_INT64:
1200             data.i64[c] = op[0]->value.i64[c0] + op[1]->value.i64[c1];
1201             break;
1202          default:
1203             unreachable("invalid type");
1204          }
1205       }
1206       break;
1207 
1208    case ir_binop_sub:
1209       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1210       for (unsigned c = 0, c0 = 0, c1 = 0;
1211            c < components;
1212            c0 += c0_inc, c1 += c1_inc, c++) {
1213 
1214          switch (op[0]->type->base_type) {
1215          case GLSL_TYPE_UINT:
1216             data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1];
1217             break;
1218          case GLSL_TYPE_INT:
1219             data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1];
1220             break;
1221          case GLSL_TYPE_FLOAT:
1222             data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1];
1223             break;
1224          case GLSL_TYPE_DOUBLE:
1225             data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1];
1226             break;
1227          case GLSL_TYPE_UINT64:
1228             data.u64[c] = op[0]->value.u64[c0] - op[1]->value.u64[c1];
1229             break;
1230          case GLSL_TYPE_INT64:
1231             data.i64[c] = op[0]->value.i64[c0] - op[1]->value.i64[c1];
1232             break;
1233          default:
1234             unreachable("invalid type");
1235          }
1236       }
1237       break;
1238 
1239    case ir_binop_add_sat:
1240       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1241          switch (op[0]->type->base_type) {
1242          case GLSL_TYPE_UINT:
1243             data.u[c] = (op[0]->value.u[c] + op[1]->value.u[c]) < op[0]->value.u[c] ? UINT32_MAX : (op[0]->value.u[c] + op[1]->value.u[c]);
1244             break;
1245          case GLSL_TYPE_INT:
1246             data.i[c] = iadd_saturate(op[0]->value.i[c], op[1]->value.i[c]);
1247             break;
1248          case GLSL_TYPE_UINT64:
1249             data.u64[c] = (op[0]->value.u64[c] + op[1]->value.u64[c]) < op[0]->value.u64[c] ? UINT64_MAX : (op[0]->value.u64[c] + op[1]->value.u64[c]);
1250             break;
1251          case GLSL_TYPE_INT64:
1252             data.i64[c] = iadd64_saturate(op[0]->value.i64[c], op[1]->value.i64[c]);
1253             break;
1254          default:
1255             unreachable("invalid type");
1256          }
1257       }
1258       break;
1259 
1260    case ir_binop_sub_sat:
1261       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1262          switch (op[0]->type->base_type) {
1263          case GLSL_TYPE_UINT:
1264             data.u[c] = (op[1]->value.u[c] > op[0]->value.u[c]) ? 0 : op[0]->value.u[c] - op[1]->value.u[c];
1265             break;
1266          case GLSL_TYPE_INT:
1267             data.i[c] = isub_saturate(op[0]->value.i[c], op[1]->value.i[c]);
1268             break;
1269          case GLSL_TYPE_UINT64:
1270             data.u64[c] = (op[1]->value.u64[c] > op[0]->value.u64[c]) ? 0 : op[0]->value.u64[c] - op[1]->value.u64[c];
1271             break;
1272          case GLSL_TYPE_INT64:
1273             data.i64[c] = isub64_saturate(op[0]->value.i64[c], op[1]->value.i64[c]);
1274             break;
1275          default:
1276             unreachable("invalid type");
1277          }
1278       }
1279       break;
1280 
1281    case ir_binop_abs_sub:
1282       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1283          switch (op[0]->type->base_type) {
1284          case GLSL_TYPE_UINT:
1285             data.u[c] = (op[1]->value.u[c] > op[0]->value.u[c]) ? op[1]->value.u[c] - op[0]->value.u[c] : op[0]->value.u[c] - op[1]->value.u[c];
1286             break;
1287          case GLSL_TYPE_INT:
1288             data.i[c] = (op[1]->value.i[c] > op[0]->value.i[c]) ? (unsigned)op[1]->value.i[c] - (unsigned)op[0]->value.i[c] : (unsigned)op[0]->value.i[c] - (unsigned)op[1]->value.i[c];
1289             break;
1290          case GLSL_TYPE_UINT64:
1291             data.u64[c] = (op[1]->value.u64[c] > op[0]->value.u64[c]) ? op[1]->value.u64[c] - op[0]->value.u64[c] : op[0]->value.u64[c] - op[1]->value.u64[c];
1292             break;
1293          case GLSL_TYPE_INT64:
1294             data.i64[c] = (op[1]->value.i64[c] > op[0]->value.i64[c]) ? (uint64_t)op[1]->value.i64[c] - (uint64_t)op[0]->value.i64[c] : (uint64_t)op[0]->value.i64[c] - (uint64_t)op[1]->value.i64[c];
1295             break;
1296          default:
1297             unreachable("invalid type");
1298          }
1299       }
1300       break;
1301 
1302    case ir_binop_avg:
1303       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1304          switch (op[0]->type->base_type) {
1305          case GLSL_TYPE_UINT:
1306             data.u[c] = (op[0]->value.u[c] >> 1) + (op[1]->value.u[c] >> 1) + ((op[0]->value.u[c] & op[1]->value.u[c]) & 1);
1307             break;
1308          case GLSL_TYPE_INT:
1309             data.i[c] = (op[0]->value.i[c] >> 1) + (op[1]->value.i[c] >> 1) + ((op[0]->value.i[c] & op[1]->value.i[c]) & 1);
1310             break;
1311          case GLSL_TYPE_UINT64:
1312             data.u64[c] = (op[0]->value.u64[c] >> 1) + (op[1]->value.u64[c] >> 1) + ((op[0]->value.u64[c] & op[1]->value.u64[c]) & 1);
1313             break;
1314          case GLSL_TYPE_INT64:
1315             data.i64[c] = (op[0]->value.i64[c] >> 1) + (op[1]->value.i64[c] >> 1) + ((op[0]->value.i64[c] & op[1]->value.i64[c]) & 1);
1316             break;
1317          default:
1318             unreachable("invalid type");
1319          }
1320       }
1321       break;
1322 
1323    case ir_binop_avg_round:
1324       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1325          switch (op[0]->type->base_type) {
1326          case GLSL_TYPE_UINT:
1327             data.u[c] = (op[0]->value.u[c] >> 1) + (op[1]->value.u[c] >> 1) + ((op[0]->value.u[c] | op[1]->value.u[c]) & 1);
1328             break;
1329          case GLSL_TYPE_INT:
1330             data.i[c] = (op[0]->value.i[c] >> 1) + (op[1]->value.i[c] >> 1) + ((op[0]->value.i[c] | op[1]->value.i[c]) & 1);
1331             break;
1332          case GLSL_TYPE_UINT64:
1333             data.u64[c] = (op[0]->value.u64[c] >> 1) + (op[1]->value.u64[c] >> 1) + ((op[0]->value.u64[c] | op[1]->value.u64[c]) & 1);
1334             break;
1335          case GLSL_TYPE_INT64:
1336             data.i64[c] = (op[0]->value.i64[c] >> 1) + (op[1]->value.i64[c] >> 1) + ((op[0]->value.i64[c] | op[1]->value.i64[c]) & 1);
1337             break;
1338          default:
1339             unreachable("invalid type");
1340          }
1341       }
1342       break;
1343 
1344    case ir_binop_mul:
1345       /* Check for equal types, or unequal types involving scalars */
1346       if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix())
1347           || op0_scalar || op1_scalar) {
1348          for (unsigned c = 0, c0 = 0, c1 = 0;
1349               c < components;
1350               c0 += c0_inc, c1 += c1_inc, c++) {
1351 
1352             switch (op[0]->type->base_type) {
1353             case GLSL_TYPE_UINT:
1354                data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1];
1355                break;
1356             case GLSL_TYPE_INT:
1357                data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1];
1358                break;
1359             case GLSL_TYPE_FLOAT:
1360                data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1];
1361                break;
1362             case GLSL_TYPE_DOUBLE:
1363                data.d[c] = op[0]->value.d[c0] * op[1]->value.d[c1];
1364                break;
1365             case GLSL_TYPE_UINT64:
1366                data.u64[c] = op[0]->value.u64[c0] * op[1]->value.u64[c1];
1367                break;
1368             case GLSL_TYPE_INT64:
1369                data.i64[c] = op[0]->value.i64[c0] * op[1]->value.i64[c1];
1370                break;
1371             default:
1372                unreachable("invalid type");
1373             }
1374          }
1375       } else {
1376          assert(op[0]->type->is_matrix() || op[1]->type->is_matrix());
1377 
1378          /* Multiply an N-by-M matrix with an M-by-P matrix.  Since either
1379           * matrix can be a GLSL vector, either N or P can be 1.
1380           *
1381           * For vec*mat, the vector is treated as a row vector.  This
1382           * means the vector is a 1-row x M-column matrix.
1383           *
1384           * For mat*vec, the vector is treated as a column vector.  Since
1385           * matrix_columns is 1 for vectors, this just works.
1386           */
1387          const unsigned n = op[0]->type->is_vector()
1388             ? 1 : op[0]->type->vector_elements;
1389          const unsigned m = op[1]->type->vector_elements;
1390          const unsigned p = op[1]->type->matrix_columns;
1391          for (unsigned j = 0; j < p; j++) {
1392             for (unsigned i = 0; i < n; i++) {
1393                for (unsigned k = 0; k < m; k++) {
1394                   if (op[0]->type->is_double())
1395                      data.d[i+n*j] += op[0]->value.d[i+n*k]*op[1]->value.d[k+m*j];
1396                   else
1397                      data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j];
1398                }
1399             }
1400          }
1401       }
1402       break;
1403 
1404    case ir_binop_mul_32x16:
1405       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1406          switch (op[0]->type->base_type) {
1407          case GLSL_TYPE_UINT:
1408             data.u[c] = op[0]->value.u[c] * (uint16_t)op[1]->value.u[c];
1409             break;
1410          case GLSL_TYPE_INT:
1411             data.i[c] = op[0]->value.i[c] * (int16_t)op[0]->value.i[c];
1412             break;
1413          default:
1414             unreachable("invalid type");
1415          }
1416       }
1417       break;
1418 
1419    case ir_binop_div:
1420       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1421       for (unsigned c = 0, c0 = 0, c1 = 0;
1422            c < components;
1423            c0 += c0_inc, c1 += c1_inc, c++) {
1424 
1425          switch (op[0]->type->base_type) {
1426          case GLSL_TYPE_UINT:
1427             data.u[c] = op[1]->value.u[c1] == 0 ? 0 : op[0]->value.u[c0] / op[1]->value.u[c1];
1428             break;
1429          case GLSL_TYPE_INT:
1430             data.i[c] = op[1]->value.i[c1] == 0 ? 0 : op[0]->value.i[c0] / op[1]->value.i[c1];
1431             break;
1432          case GLSL_TYPE_FLOAT:
1433             data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1];
1434             break;
1435          case GLSL_TYPE_DOUBLE:
1436             data.d[c] = op[0]->value.d[c0] / op[1]->value.d[c1];
1437             break;
1438          case GLSL_TYPE_UINT64:
1439             data.u64[c] = op[1]->value.u64[c1] == 0 ? 0 : op[0]->value.u64[c0] / op[1]->value.u64[c1];
1440             break;
1441          case GLSL_TYPE_INT64:
1442             data.i64[c] = op[1]->value.i64[c1] == 0 ? 0 : op[0]->value.i64[c0] / op[1]->value.i64[c1];
1443             break;
1444          default:
1445             unreachable("invalid type");
1446          }
1447       }
1448       break;
1449 
1450    case ir_binop_mod:
1451       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1452       for (unsigned c = 0, c0 = 0, c1 = 0;
1453            c < components;
1454            c0 += c0_inc, c1 += c1_inc, c++) {
1455 
1456          switch (op[0]->type->base_type) {
1457          case GLSL_TYPE_UINT:
1458             data.u[c] = op[1]->value.u[c1] == 0 ? 0 : op[0]->value.u[c0] % op[1]->value.u[c1];
1459             break;
1460          case GLSL_TYPE_INT:
1461             data.i[c] = op[1]->value.i[c1] == 0 ? 0 : op[0]->value.i[c0] % op[1]->value.i[c1];
1462             break;
1463          case GLSL_TYPE_FLOAT:
1464             data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1] * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]);
1465             break;
1466          case GLSL_TYPE_DOUBLE:
1467             data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1] * floor(op[0]->value.d[c0] / op[1]->value.d[c1]);
1468             break;
1469          case GLSL_TYPE_UINT64:
1470             data.u64[c] = op[1]->value.u64[c1] == 0 ? 0 : op[0]->value.u64[c0] % op[1]->value.u64[c1];
1471             break;
1472          case GLSL_TYPE_INT64:
1473             data.i64[c] = op[1]->value.i64[c1] == 0 ? 0 : op[0]->value.i64[c0] % op[1]->value.i64[c1];
1474             break;
1475          default:
1476             unreachable("invalid type");
1477          }
1478       }
1479       break;
1480 
1481    case ir_binop_less:
1482       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1483          switch (op[0]->type->base_type) {
1484          case GLSL_TYPE_UINT:
1485             data.b[c] = op[0]->value.u[c] < op[1]->value.u[c];
1486             break;
1487          case GLSL_TYPE_INT:
1488             data.b[c] = op[0]->value.i[c] < op[1]->value.i[c];
1489             break;
1490          case GLSL_TYPE_FLOAT:
1491             data.b[c] = op[0]->value.f[c] < op[1]->value.f[c];
1492             break;
1493          case GLSL_TYPE_DOUBLE:
1494             data.b[c] = op[0]->value.d[c] < op[1]->value.d[c];
1495             break;
1496          case GLSL_TYPE_UINT64:
1497             data.b[c] = op[0]->value.u64[c] < op[1]->value.u64[c];
1498             break;
1499          case GLSL_TYPE_INT64:
1500             data.b[c] = op[0]->value.i64[c] < op[1]->value.i64[c];
1501             break;
1502          default:
1503             unreachable("invalid type");
1504          }
1505       }
1506       break;
1507 
1508    case ir_binop_gequal:
1509       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1510          switch (op[0]->type->base_type) {
1511          case GLSL_TYPE_UINT:
1512             data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c];
1513             break;
1514          case GLSL_TYPE_INT:
1515             data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c];
1516             break;
1517          case GLSL_TYPE_FLOAT:
1518             data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c];
1519             break;
1520          case GLSL_TYPE_DOUBLE:
1521             data.b[c] = op[0]->value.d[c] >= op[1]->value.d[c];
1522             break;
1523          case GLSL_TYPE_UINT64:
1524             data.b[c] = op[0]->value.u64[c] >= op[1]->value.u64[c];
1525             break;
1526          case GLSL_TYPE_INT64:
1527             data.b[c] = op[0]->value.i64[c] >= op[1]->value.i64[c];
1528             break;
1529          default:
1530             unreachable("invalid type");
1531          }
1532       }
1533       break;
1534 
1535    case ir_binop_equal:
1536       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1537          switch (op[0]->type->base_type) {
1538          case GLSL_TYPE_UINT:
1539             data.b[c] = op[0]->value.u[c] == op[1]->value.u[c];
1540             break;
1541          case GLSL_TYPE_INT:
1542             data.b[c] = op[0]->value.i[c] == op[1]->value.i[c];
1543             break;
1544          case GLSL_TYPE_FLOAT:
1545             data.b[c] = op[0]->value.f[c] == op[1]->value.f[c];
1546             break;
1547          case GLSL_TYPE_DOUBLE:
1548             data.b[c] = op[0]->value.d[c] == op[1]->value.d[c];
1549             break;
1550          case GLSL_TYPE_UINT64:
1551             data.b[c] = op[0]->value.u64[c] == op[1]->value.u64[c];
1552             break;
1553          case GLSL_TYPE_INT64:
1554             data.b[c] = op[0]->value.i64[c] == op[1]->value.i64[c];
1555             break;
1556          case GLSL_TYPE_BOOL:
1557             data.b[c] = op[0]->value.b[c] == op[1]->value.b[c];
1558             break;
1559          default:
1560             unreachable("invalid type");
1561          }
1562       }
1563       break;
1564 
1565    case ir_binop_nequal:
1566       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1567          switch (op[0]->type->base_type) {
1568          case GLSL_TYPE_UINT:
1569             data.b[c] = op[0]->value.u[c] != op[1]->value.u[c];
1570             break;
1571          case GLSL_TYPE_INT:
1572             data.b[c] = op[0]->value.i[c] != op[1]->value.i[c];
1573             break;
1574          case GLSL_TYPE_FLOAT:
1575             data.b[c] = op[0]->value.f[c] != op[1]->value.f[c];
1576             break;
1577          case GLSL_TYPE_DOUBLE:
1578             data.b[c] = op[0]->value.d[c] != op[1]->value.d[c];
1579             break;
1580          case GLSL_TYPE_UINT64:
1581             data.b[c] = op[0]->value.u64[c] != op[1]->value.u64[c];
1582             break;
1583          case GLSL_TYPE_INT64:
1584             data.b[c] = op[0]->value.i64[c] != op[1]->value.i64[c];
1585             break;
1586          case GLSL_TYPE_BOOL:
1587             data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
1588             break;
1589          default:
1590             unreachable("invalid type");
1591          }
1592       }
1593       break;
1594 
1595    case ir_binop_all_equal:
1596       data.b[0] = op[0]->has_value(op[1]);
1597       break;
1598 
1599    case ir_binop_any_nequal:
1600       data.b[0] = !op[0]->has_value(op[1]);
1601       break;
1602 
1603    case ir_binop_lshift:
1604       assert(op[0]->type->base_type == GLSL_TYPE_UINT ||
1605              op[0]->type->base_type == GLSL_TYPE_INT ||
1606              op[0]->type->base_type == GLSL_TYPE_UINT64 ||
1607              op[0]->type->base_type == GLSL_TYPE_INT64);
1608       assert(op[1]->type->base_type == GLSL_TYPE_UINT ||
1609              op[1]->type->base_type == GLSL_TYPE_INT ||
1610              op[1]->type->base_type == GLSL_TYPE_UINT64 ||
1611              op[1]->type->base_type == GLSL_TYPE_INT64);
1612       for (unsigned c = 0, c0 = 0, c1 = 0;
1613            c < components;
1614            c0 += c0_inc, c1 += c1_inc, c++) {
1615 
1616          switch (op[0]->type->base_type) {
1617          case GLSL_TYPE_UINT:
1618             data.u[c] = op[0]->value.u[c0] << op[1]->value.u[c1];
1619             break;
1620          case GLSL_TYPE_INT:
1621             data.i[c] = op[0]->value.i[c0] << op[1]->value.i[c1];
1622             break;
1623          case GLSL_TYPE_UINT64:
1624             data.u64[c] = op[0]->value.u64[c0] << op[1]->value.u64[c1];
1625             break;
1626          case GLSL_TYPE_INT64:
1627             data.i64[c] = op[0]->value.i64[c0] << op[1]->value.i64[c1];
1628             break;
1629          default:
1630             unreachable("invalid type");
1631          }
1632       }
1633       break;
1634 
1635    case ir_binop_rshift:
1636       assert(op[0]->type->base_type == GLSL_TYPE_UINT ||
1637              op[0]->type->base_type == GLSL_TYPE_INT ||
1638              op[0]->type->base_type == GLSL_TYPE_UINT64 ||
1639              op[0]->type->base_type == GLSL_TYPE_INT64);
1640       assert(op[1]->type->base_type == GLSL_TYPE_UINT ||
1641              op[1]->type->base_type == GLSL_TYPE_INT ||
1642              op[1]->type->base_type == GLSL_TYPE_UINT64 ||
1643              op[1]->type->base_type == GLSL_TYPE_INT64);
1644       for (unsigned c = 0, c0 = 0, c1 = 0;
1645            c < components;
1646            c0 += c0_inc, c1 += c1_inc, c++) {
1647 
1648          switch (op[0]->type->base_type) {
1649          case GLSL_TYPE_UINT:
1650             data.u[c] = op[0]->value.u[c0] >> op[1]->value.u[c1];
1651             break;
1652          case GLSL_TYPE_INT:
1653             data.i[c] = op[0]->value.i[c0] >> op[1]->value.i[c1];
1654             break;
1655          case GLSL_TYPE_UINT64:
1656             data.u64[c] = op[0]->value.u64[c0] >> op[1]->value.u64[c1];
1657             break;
1658          case GLSL_TYPE_INT64:
1659             data.i64[c] = op[0]->value.i64[c0] >> op[1]->value.i64[c1];
1660             break;
1661          default:
1662             unreachable("invalid type");
1663          }
1664       }
1665       break;
1666 
1667    case ir_binop_bit_and:
1668       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1669       for (unsigned c = 0, c0 = 0, c1 = 0;
1670            c < components;
1671            c0 += c0_inc, c1 += c1_inc, c++) {
1672 
1673          switch (op[0]->type->base_type) {
1674          case GLSL_TYPE_UINT:
1675             data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1];
1676             break;
1677          case GLSL_TYPE_INT:
1678             data.i[c] = op[0]->value.i[c0] & op[1]->value.i[c1];
1679             break;
1680          case GLSL_TYPE_UINT64:
1681             data.u64[c] = op[0]->value.u64[c0] & op[1]->value.u64[c1];
1682             break;
1683          case GLSL_TYPE_INT64:
1684             data.i64[c] = op[0]->value.i64[c0] & op[1]->value.i64[c1];
1685             break;
1686          default:
1687             unreachable("invalid type");
1688          }
1689       }
1690       break;
1691 
1692    case ir_binop_bit_xor:
1693       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1694       for (unsigned c = 0, c0 = 0, c1 = 0;
1695            c < components;
1696            c0 += c0_inc, c1 += c1_inc, c++) {
1697 
1698          switch (op[0]->type->base_type) {
1699          case GLSL_TYPE_UINT:
1700             data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1];
1701             break;
1702          case GLSL_TYPE_INT:
1703             data.i[c] = op[0]->value.i[c0] ^ op[1]->value.i[c1];
1704             break;
1705          case GLSL_TYPE_UINT64:
1706             data.u64[c] = op[0]->value.u64[c0] ^ op[1]->value.u64[c1];
1707             break;
1708          case GLSL_TYPE_INT64:
1709             data.i64[c] = op[0]->value.i64[c0] ^ op[1]->value.i64[c1];
1710             break;
1711          default:
1712             unreachable("invalid type");
1713          }
1714       }
1715       break;
1716 
1717    case ir_binop_bit_or:
1718       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1719       for (unsigned c = 0, c0 = 0, c1 = 0;
1720            c < components;
1721            c0 += c0_inc, c1 += c1_inc, c++) {
1722 
1723          switch (op[0]->type->base_type) {
1724          case GLSL_TYPE_UINT:
1725             data.u[c] = op[0]->value.u[c0] | op[1]->value.u[c1];
1726             break;
1727          case GLSL_TYPE_INT:
1728             data.i[c] = op[0]->value.i[c0] | op[1]->value.i[c1];
1729             break;
1730          case GLSL_TYPE_UINT64:
1731             data.u64[c] = op[0]->value.u64[c0] | op[1]->value.u64[c1];
1732             break;
1733          case GLSL_TYPE_INT64:
1734             data.i64[c] = op[0]->value.i64[c0] | op[1]->value.i64[c1];
1735             break;
1736          default:
1737             unreachable("invalid type");
1738          }
1739       }
1740       break;
1741 
1742    case ir_binop_logic_and:
1743       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1744          switch (op[0]->type->base_type) {
1745          case GLSL_TYPE_BOOL:
1746             data.b[c] = op[0]->value.b[c] && op[1]->value.b[c];
1747             break;
1748          default:
1749             unreachable("invalid type");
1750          }
1751       }
1752       break;
1753 
1754    case ir_binop_logic_xor:
1755       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1756          switch (op[0]->type->base_type) {
1757          case GLSL_TYPE_BOOL:
1758             data.b[c] = op[0]->value.b[c] != op[1]->value.b[c];
1759             break;
1760          default:
1761             unreachable("invalid type");
1762          }
1763       }
1764       break;
1765 
1766    case ir_binop_logic_or:
1767       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1768          switch (op[0]->type->base_type) {
1769          case GLSL_TYPE_BOOL:
1770             data.b[c] = op[0]->value.b[c] || op[1]->value.b[c];
1771             break;
1772          default:
1773             unreachable("invalid type");
1774          }
1775       }
1776       break;
1777 
1778    case ir_binop_dot:
1779       switch (op[0]->type->base_type) {
1780       case GLSL_TYPE_FLOAT:
1781          data.f[0] = dot_f(op[0], op[1]);
1782          break;
1783       case GLSL_TYPE_DOUBLE:
1784          data.d[0] = dot_d(op[0], op[1]);
1785          break;
1786       default:
1787          unreachable("invalid type");
1788       }
1789       break;
1790 
1791    case ir_binop_min:
1792       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1793       for (unsigned c = 0, c0 = 0, c1 = 0;
1794            c < components;
1795            c0 += c0_inc, c1 += c1_inc, c++) {
1796 
1797          switch (op[0]->type->base_type) {
1798          case GLSL_TYPE_UINT:
1799             data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]);
1800             break;
1801          case GLSL_TYPE_INT:
1802             data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]);
1803             break;
1804          case GLSL_TYPE_FLOAT:
1805             data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]);
1806             break;
1807          case GLSL_TYPE_DOUBLE:
1808             data.d[c] = MIN2(op[0]->value.d[c0], op[1]->value.d[c1]);
1809             break;
1810          case GLSL_TYPE_UINT64:
1811             data.u64[c] = MIN2(op[0]->value.u64[c0], op[1]->value.u64[c1]);
1812             break;
1813          case GLSL_TYPE_INT64:
1814             data.i64[c] = MIN2(op[0]->value.i64[c0], op[1]->value.i64[c1]);
1815             break;
1816          default:
1817             unreachable("invalid type");
1818          }
1819       }
1820       break;
1821 
1822    case ir_binop_max:
1823       assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar);
1824       for (unsigned c = 0, c0 = 0, c1 = 0;
1825            c < components;
1826            c0 += c0_inc, c1 += c1_inc, c++) {
1827 
1828          switch (op[0]->type->base_type) {
1829          case GLSL_TYPE_UINT:
1830             data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]);
1831             break;
1832          case GLSL_TYPE_INT:
1833             data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]);
1834             break;
1835          case GLSL_TYPE_FLOAT:
1836             data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]);
1837             break;
1838          case GLSL_TYPE_DOUBLE:
1839             data.d[c] = MAX2(op[0]->value.d[c0], op[1]->value.d[c1]);
1840             break;
1841          case GLSL_TYPE_UINT64:
1842             data.u64[c] = MAX2(op[0]->value.u64[c0], op[1]->value.u64[c1]);
1843             break;
1844          case GLSL_TYPE_INT64:
1845             data.i64[c] = MAX2(op[0]->value.i64[c0], op[1]->value.i64[c1]);
1846             break;
1847          default:
1848             unreachable("invalid type");
1849          }
1850       }
1851       break;
1852 
1853    case ir_binop_pow:
1854       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1855          switch (op[0]->type->base_type) {
1856          case GLSL_TYPE_FLOAT:
1857             data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]);
1858             break;
1859          default:
1860             unreachable("invalid type");
1861          }
1862       }
1863       break;
1864 
1865    case ir_binop_ldexp:
1866       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1867          switch (op[0]->type->base_type) {
1868          case GLSL_TYPE_FLOAT:
1869             data.f[c] = ldexpf_flush_subnormal(op[0]->value.f[c], op[1]->value.i[c]);
1870             break;
1871          case GLSL_TYPE_DOUBLE:
1872             data.d[c] = ldexp_flush_subnormal(op[0]->value.d[c], op[1]->value.i[c]);
1873             break;
1874          default:
1875             unreachable("invalid type");
1876          }
1877       }
1878       break;
1879 
1880    case ir_binop_vector_extract: {
1881       const int c = CLAMP(op[1]->value.i[0], 0,
1882                           (int) op[0]->type->vector_elements - 1);
1883 
1884       switch (op[0]->type->base_type) {
1885       case GLSL_TYPE_UINT:
1886          data.u[0] = op[0]->value.u[c];
1887          break;
1888       case GLSL_TYPE_INT:
1889          data.i[0] = op[0]->value.i[c];
1890          break;
1891       case GLSL_TYPE_FLOAT:
1892          data.f[0] = op[0]->value.f[c];
1893          break;
1894       case GLSL_TYPE_DOUBLE:
1895          data.d[0] = op[0]->value.d[c];
1896          break;
1897       case GLSL_TYPE_UINT64:
1898          data.u64[0] = op[0]->value.u64[c];
1899          break;
1900       case GLSL_TYPE_INT64:
1901          data.i64[0] = op[0]->value.i64[c];
1902          break;
1903       case GLSL_TYPE_BOOL:
1904          data.b[0] = op[0]->value.b[c];
1905          break;
1906       default:
1907          unreachable("invalid type");
1908       }
1909       break;
1910    }
1911 
1912    case ir_binop_atan2:
1913       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1914          switch (op[0]->type->base_type) {
1915          case GLSL_TYPE_FLOAT:
1916             data.f[c] = atan2(op[0]->value.f[c], op[1]->value.f[c]);
1917             break;
1918          default:
1919             unreachable("invalid type");
1920          }
1921       }
1922       break;
1923 
1924    case ir_triop_fma:
1925       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1926          switch (op[0]->type->base_type) {
1927          case GLSL_TYPE_FLOAT:
1928             data.f[c] = op[0]->value.f[c] * op[1]->value.f[c] + op[2]->value.f[c];
1929             break;
1930          case GLSL_TYPE_DOUBLE:
1931             data.d[c] = op[0]->value.d[c] * op[1]->value.d[c] + op[2]->value.d[c];
1932             break;
1933          default:
1934             unreachable("invalid type");
1935          }
1936       }
1937       break;
1938 
1939    case ir_triop_lrp: {
1940       assert(op[0]->type->is_float() || op[0]->type->is_double());
1941       assert(op[1]->type->is_float() || op[1]->type->is_double());
1942       assert(op[2]->type->is_float() || op[2]->type->is_double());
1943 
1944       unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1;
1945       for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) {
1946          switch (this->type->base_type) {
1947          case GLSL_TYPE_FLOAT:
1948             data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) + (op[1]->value.f[c] * op[2]->value.f[c2]);
1949             break;
1950          case GLSL_TYPE_DOUBLE:
1951             data.d[c] = op[0]->value.d[c] * (1.0 - op[2]->value.d[c2]) + (op[1]->value.d[c] * op[2]->value.d[c2]);
1952             break;
1953          default:
1954             unreachable("invalid type");
1955          }
1956       }
1957       break;
1958    }
1959 
1960    case ir_triop_csel:
1961       for (unsigned c = 0; c < components; c++) {
1962          switch (this->type->base_type) {
1963          case GLSL_TYPE_UINT:
1964             data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c] : op[2]->value.u[c];
1965             break;
1966          case GLSL_TYPE_INT:
1967             data.i[c] = op[0]->value.b[c] ? op[1]->value.i[c] : op[2]->value.i[c];
1968             break;
1969          case GLSL_TYPE_FLOAT:
1970             data.f[c] = op[0]->value.b[c] ? op[1]->value.f[c] : op[2]->value.f[c];
1971             break;
1972          case GLSL_TYPE_DOUBLE:
1973             data.d[c] = op[0]->value.b[c] ? op[1]->value.d[c] : op[2]->value.d[c];
1974             break;
1975          case GLSL_TYPE_UINT64:
1976             data.u64[c] = op[0]->value.b[c] ? op[1]->value.u64[c] : op[2]->value.u64[c];
1977             break;
1978          case GLSL_TYPE_INT64:
1979             data.i64[c] = op[0]->value.b[c] ? op[1]->value.i64[c] : op[2]->value.i64[c];
1980             break;
1981          case GLSL_TYPE_BOOL:
1982             data.b[c] = op[0]->value.b[c] ? op[1]->value.b[c] : op[2]->value.b[c];
1983             break;
1984          default:
1985             unreachable("invalid type");
1986          }
1987       }
1988       break;
1989 
1990    case ir_triop_bitfield_extract:
1991       for (unsigned c = 0; c < op[0]->type->components(); c++) {
1992          switch (op[0]->type->base_type) {
1993          case GLSL_TYPE_UINT:
1994             data.i[c] = bitfield_extract_uint(op[0]->value.u[c], op[1]->value.i[c], op[2]->value.i[c]);
1995             break;
1996          case GLSL_TYPE_INT:
1997             data.i[c] = bitfield_extract_int(op[0]->value.i[c], op[1]->value.i[c], op[2]->value.i[c]);
1998             break;
1999          default:
2000             unreachable("invalid type");
2001          }
2002       }
2003       break;
2004 
2005    case ir_triop_vector_insert: {
2006       const unsigned idx = op[2]->value.u[0];
2007 
2008       memcpy(&data, &op[0]->value, sizeof(data));
2009 
2010       switch (this->type->base_type) {
2011       case GLSL_TYPE_UINT:
2012          data.u[idx] = op[1]->value.u[0];
2013          break;
2014       case GLSL_TYPE_INT:
2015          data.i[idx] = op[1]->value.i[0];
2016          break;
2017       case GLSL_TYPE_FLOAT:
2018          data.f[idx] = op[1]->value.f[0];
2019          break;
2020       case GLSL_TYPE_DOUBLE:
2021          data.d[idx] = op[1]->value.d[0];
2022          break;
2023       case GLSL_TYPE_UINT64:
2024          data.u64[idx] = op[1]->value.u64[0];
2025          break;
2026       case GLSL_TYPE_INT64:
2027          data.i64[idx] = op[1]->value.i64[0];
2028          break;
2029       case GLSL_TYPE_BOOL:
2030          data.b[idx] = op[1]->value.b[0];
2031          break;
2032       default:
2033          unreachable("invalid type");
2034       }
2035       break;
2036    }
2037 
2038    case ir_quadop_bitfield_insert:
2039       for (unsigned c = 0; c < op[0]->type->components(); c++) {
2040          switch (op[0]->type->base_type) {
2041          case GLSL_TYPE_UINT:
2042             data.u[c] = bitfield_insert(op[0]->value.u[c], op[1]->value.u[c], op[2]->value.i[c], op[3]->value.i[c]);
2043             break;
2044          case GLSL_TYPE_INT:
2045             data.i[c] = bitfield_insert(op[0]->value.i[c], op[1]->value.i[c], op[2]->value.i[c], op[3]->value.i[c]);
2046             break;
2047          default:
2048             unreachable("invalid type");
2049          }
2050       }
2051       break;
2052 
2053    case ir_quadop_vector:
2054       for (unsigned c = 0; c < this->type->vector_elements; c++) {
2055          switch (this->type->base_type) {
2056          case GLSL_TYPE_UINT:
2057             data.u[c] = op[c]->value.u[0];
2058             break;
2059          case GLSL_TYPE_INT:
2060             data.i[c] = op[c]->value.i[0];
2061             break;
2062          case GLSL_TYPE_FLOAT:
2063             data.f[c] = op[c]->value.f[0];
2064             break;
2065          case GLSL_TYPE_DOUBLE:
2066             data.d[c] = op[c]->value.d[0];
2067             break;
2068          case GLSL_TYPE_UINT64:
2069             data.u64[c] = op[c]->value.u64[0];
2070             break;
2071          case GLSL_TYPE_INT64:
2072             data.i64[c] = op[c]->value.i64[0];
2073             break;
2074          case GLSL_TYPE_BOOL:
2075             data.b[c] = op[c]->value.b[0];
2076             break;
2077          default:
2078             unreachable("invalid type");
2079          }
2080       }
2081       break;
2082 
2083    default:
2084       /* FINISHME: Should handle all expression types. */
2085       return NULL;
2086    }
2087 
2088