1 ir_function_signature
*
2 umul64(void *mem_ctx
, builtin_available_predicate avail
)
4 ir_function_signature
*const sig
=
5 new(mem_ctx
) ir_function_signature(glsl_type::uvec2_type
, avail
);
6 ir_factory
body(&sig
->body
, mem_ctx
);
7 sig
->is_defined
= true;
9 exec_list sig_parameters
;
11 ir_variable
*const r0001
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "a", ir_var_function_in
);
12 sig_parameters
.push_tail(r0001
);
13 ir_variable
*const r0002
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "b", ir_var_function_in
);
14 sig_parameters
.push_tail(r0002
);
15 ir_variable
*const r0003
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "result", ir_var_auto
);
17 body
.emit(assign(r0003
, imul_high(swizzle_x(r0001
), swizzle_x(r0002
)), 0x02));
19 body
.emit(assign(r0003
, mul(swizzle_x(r0001
), swizzle_x(r0002
)), 0x01));
21 ir_expression
*const r0004
= mul(swizzle_x(r0001
), swizzle_y(r0002
));
22 ir_expression
*const r0005
= mul(swizzle_y(r0001
), swizzle_x(r0002
));
23 ir_expression
*const r0006
= add(r0004
, r0005
);
24 body
.emit(assign(r0003
, add(swizzle_y(r0003
), r0006
), 0x02));
26 body
.emit(ret(r0003
));
28 sig
->replace_parameters(&sig_parameters
);
31 ir_function_signature
*
32 sign64(void *mem_ctx
, builtin_available_predicate avail
)
34 ir_function_signature
*const sig
=
35 new(mem_ctx
) ir_function_signature(glsl_type::ivec2_type
, avail
);
36 ir_factory
body(&sig
->body
, mem_ctx
);
37 sig
->is_defined
= true;
39 exec_list sig_parameters
;
41 ir_variable
*const r0007
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "a", ir_var_function_in
);
42 sig_parameters
.push_tail(r0007
);
43 ir_variable
*const r0008
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "result", ir_var_auto
);
45 body
.emit(assign(r0008
, rshift(swizzle_y(r0007
), body
.constant(int(31))), 0x02));
47 ir_expression
*const r0009
= bit_or(swizzle_x(r0007
), swizzle_y(r0007
));
48 ir_expression
*const r000A
= nequal(r0009
, body
.constant(int(0)));
49 ir_expression
*const r000B
= expr(ir_unop_b2i
, r000A
);
50 body
.emit(assign(r0008
, bit_or(swizzle_y(r0008
), r000B
), 0x01));
52 body
.emit(ret(r0008
));
54 sig
->replace_parameters(&sig_parameters
);
57 ir_function_signature
*
58 udivmod64(void *mem_ctx
, builtin_available_predicate avail
)
60 ir_function_signature
*const sig
=
61 new(mem_ctx
) ir_function_signature(glsl_type::uvec4_type
, avail
);
62 ir_factory
body(&sig
->body
, mem_ctx
);
63 sig
->is_defined
= true;
65 exec_list sig_parameters
;
67 ir_variable
*const r000C
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "n", ir_var_function_in
);
68 sig_parameters
.push_tail(r000C
);
69 ir_variable
*const r000D
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "d", ir_var_function_in
);
70 sig_parameters
.push_tail(r000D
);
71 ir_variable
*const r000E
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
73 ir_variable
*const r000F
= new(mem_ctx
) ir_variable(glsl_type::uint64_t_type
, "n64", ir_var_auto
);
75 ir_variable
*const r0010
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "log2_denom", ir_var_auto
);
77 ir_variable
*const r0011
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "quot", ir_var_auto
);
79 body
.emit(assign(r0011
, ir_constant::zero(mem_ctx
, glsl_type::uvec2_type
), 0x03));
81 ir_expression
*const r0012
= expr(ir_unop_find_msb
, swizzle_y(r000D
));
82 body
.emit(assign(r0010
, add(r0012
, body
.constant(int(32))), 0x01));
85 ir_expression
*const r0014
= equal(swizzle_y(r000D
), body
.constant(0u));
86 ir_expression
*const r0015
= gequal(swizzle_y(r000C
), swizzle_x(r000D
));
87 ir_expression
*const r0016
= logic_and(r0014
, r0015
);
88 ir_if
*f0013
= new(mem_ctx
) ir_if(operand(r0016
).val
);
89 exec_list
*const f0013_parent_instructions
= body
.instructions
;
91 /* THEN INSTRUCTIONS */
92 body
.instructions
= &f0013
->then_instructions
;
94 ir_variable
*const r0017
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
96 ir_variable
*const r0018
= body
.make_temp(glsl_type::int_type
, "findMSB_retval");
97 body
.emit(assign(r0018
, expr(ir_unop_find_msb
, swizzle_x(r000D
)), 0x01));
99 body
.emit(assign(r0010
, r0018
, 0x01));
101 body
.emit(assign(r0017
, body
.constant(int(31)), 0x01));
104 ir_loop
*f0019
= new(mem_ctx
) ir_loop();
105 exec_list
*const f0019_parent_instructions
= body
.instructions
;
107 body
.instructions
= &f0019
->body_instructions
;
110 ir_expression
*const r001B
= less(r0017
, body
.constant(int(1)));
111 ir_if
*f001A
= new(mem_ctx
) ir_if(operand(r001B
).val
);
112 exec_list
*const f001A_parent_instructions
= body
.instructions
;
114 /* THEN INSTRUCTIONS */
115 body
.instructions
= &f001A
->then_instructions
;
117 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
120 body
.instructions
= f001A_parent_instructions
;
126 ir_expression
*const r001D
= sub(body
.constant(int(31)), r0017
);
127 ir_expression
*const r001E
= lequal(r0018
, r001D
);
128 ir_expression
*const r001F
= lshift(swizzle_x(r000D
), r0017
);
129 ir_expression
*const r0020
= lequal(r001F
, swizzle_y(r000C
));
130 ir_expression
*const r0021
= logic_and(r001E
, r0020
);
131 ir_if
*f001C
= new(mem_ctx
) ir_if(operand(r0021
).val
);
132 exec_list
*const f001C_parent_instructions
= body
.instructions
;
134 /* THEN INSTRUCTIONS */
135 body
.instructions
= &f001C
->then_instructions
;
137 ir_expression
*const r0022
= lshift(swizzle_x(r000D
), r0017
);
138 body
.emit(assign(r000C
, sub(swizzle_y(r000C
), r0022
), 0x02));
140 ir_expression
*const r0023
= lshift(body
.constant(1u), r0017
);
141 body
.emit(assign(r0011
, bit_or(swizzle_y(r0011
), r0023
), 0x02));
144 body
.instructions
= f001C_parent_instructions
;
149 body
.emit(assign(r0017
, add(r0017
, body
.constant(int(-1))), 0x01));
153 body
.instructions
= f0019_parent_instructions
;
157 ir_expression
*const r0025
= lequal(swizzle_x(r000D
), swizzle_y(r000C
));
158 ir_if
*f0024
= new(mem_ctx
) ir_if(operand(r0025
).val
);
159 exec_list
*const f0024_parent_instructions
= body
.instructions
;
161 /* THEN INSTRUCTIONS */
162 body
.instructions
= &f0024
->then_instructions
;
164 body
.emit(assign(r000C
, sub(swizzle_y(r000C
), swizzle_x(r000D
)), 0x02));
166 body
.emit(assign(r0011
, bit_or(swizzle_y(r0011
), body
.constant(1u)), 0x02));
169 body
.instructions
= f0024_parent_instructions
;
175 body
.instructions
= f0013_parent_instructions
;
180 ir_variable
*const r0026
= body
.make_temp(glsl_type::uint64_t_type
, "packUint2x32_retval");
181 body
.emit(assign(r0026
, expr(ir_unop_pack_uint_2x32
, r000D
), 0x01));
183 body
.emit(assign(r000F
, expr(ir_unop_pack_uint_2x32
, r000C
), 0x01));
185 body
.emit(assign(r000E
, body
.constant(int(31)), 0x01));
188 ir_loop
*f0027
= new(mem_ctx
) ir_loop();
189 exec_list
*const f0027_parent_instructions
= body
.instructions
;
191 body
.instructions
= &f0027
->body_instructions
;
194 ir_expression
*const r0029
= less(r000E
, body
.constant(int(1)));
195 ir_if
*f0028
= new(mem_ctx
) ir_if(operand(r0029
).val
);
196 exec_list
*const f0028_parent_instructions
= body
.instructions
;
198 /* THEN INSTRUCTIONS */
199 body
.instructions
= &f0028
->then_instructions
;
201 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
204 body
.instructions
= f0028_parent_instructions
;
210 ir_expression
*const r002B
= sub(body
.constant(int(63)), r000E
);
211 ir_expression
*const r002C
= lequal(r0010
, r002B
);
212 ir_expression
*const r002D
= lshift(r0026
, r000E
);
213 ir_expression
*const r002E
= lequal(r002D
, r000F
);
214 ir_expression
*const r002F
= logic_and(r002C
, r002E
);
215 ir_if
*f002A
= new(mem_ctx
) ir_if(operand(r002F
).val
);
216 exec_list
*const f002A_parent_instructions
= body
.instructions
;
218 /* THEN INSTRUCTIONS */
219 body
.instructions
= &f002A
->then_instructions
;
221 ir_expression
*const r0030
= lshift(r0026
, r000E
);
222 body
.emit(assign(r000F
, sub(r000F
, r0030
), 0x01));
224 ir_expression
*const r0031
= lshift(body
.constant(1u), r000E
);
225 body
.emit(assign(r0011
, bit_or(swizzle_x(r0011
), r0031
), 0x01));
228 body
.instructions
= f002A_parent_instructions
;
233 body
.emit(assign(r000E
, add(r000E
, body
.constant(int(-1))), 0x01));
237 body
.instructions
= f0027_parent_instructions
;
241 ir_expression
*const r0033
= lequal(r0026
, r000F
);
242 ir_if
*f0032
= new(mem_ctx
) ir_if(operand(r0033
).val
);
243 exec_list
*const f0032_parent_instructions
= body
.instructions
;
245 /* THEN INSTRUCTIONS */
246 body
.instructions
= &f0032
->then_instructions
;
248 body
.emit(assign(r000F
, sub(r000F
, r0026
), 0x01));
250 body
.emit(assign(r0011
, bit_or(swizzle_x(r0011
), body
.constant(1u)), 0x01));
253 body
.instructions
= f0032_parent_instructions
;
258 ir_variable
*const r0034
= body
.make_temp(glsl_type::uvec4_type
, "vec_ctor");
259 body
.emit(assign(r0034
, r0011
, 0x03));
261 body
.emit(assign(r0034
, expr(ir_unop_unpack_uint_2x32
, r000F
), 0x0c));
263 body
.emit(ret(r0034
));
265 sig
->replace_parameters(&sig_parameters
);
268 ir_function_signature
*
269 udiv64(void *mem_ctx
, builtin_available_predicate avail
)
271 ir_function_signature
*const sig
=
272 new(mem_ctx
) ir_function_signature(glsl_type::uvec2_type
, avail
);
273 ir_factory
body(&sig
->body
, mem_ctx
);
274 sig
->is_defined
= true;
276 exec_list sig_parameters
;
278 ir_variable
*const r0035
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "n", ir_var_function_in
);
279 sig_parameters
.push_tail(r0035
);
280 ir_variable
*const r0036
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "d", ir_var_function_in
);
281 sig_parameters
.push_tail(r0036
);
282 ir_variable
*const r0037
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "n", ir_var_auto
);
284 body
.emit(assign(r0037
, r0035
, 0x03));
286 ir_variable
*const r0038
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
288 ir_variable
*const r0039
= new(mem_ctx
) ir_variable(glsl_type::uint64_t_type
, "n64", ir_var_auto
);
290 ir_variable
*const r003A
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "log2_denom", ir_var_auto
);
292 ir_variable
*const r003B
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "quot", ir_var_auto
);
294 body
.emit(assign(r003B
, ir_constant::zero(mem_ctx
, glsl_type::uvec2_type
), 0x03));
296 ir_expression
*const r003C
= expr(ir_unop_find_msb
, swizzle_y(r0036
));
297 body
.emit(assign(r003A
, add(r003C
, body
.constant(int(32))), 0x01));
300 ir_expression
*const r003E
= equal(swizzle_y(r0036
), body
.constant(0u));
301 ir_expression
*const r003F
= gequal(swizzle_y(r0035
), swizzle_x(r0036
));
302 ir_expression
*const r0040
= logic_and(r003E
, r003F
);
303 ir_if
*f003D
= new(mem_ctx
) ir_if(operand(r0040
).val
);
304 exec_list
*const f003D_parent_instructions
= body
.instructions
;
306 /* THEN INSTRUCTIONS */
307 body
.instructions
= &f003D
->then_instructions
;
309 ir_variable
*const r0041
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
311 ir_variable
*const r0042
= body
.make_temp(glsl_type::int_type
, "findMSB_retval");
312 body
.emit(assign(r0042
, expr(ir_unop_find_msb
, swizzle_x(r0036
)), 0x01));
314 body
.emit(assign(r003A
, r0042
, 0x01));
316 body
.emit(assign(r0041
, body
.constant(int(31)), 0x01));
319 ir_loop
*f0043
= new(mem_ctx
) ir_loop();
320 exec_list
*const f0043_parent_instructions
= body
.instructions
;
322 body
.instructions
= &f0043
->body_instructions
;
325 ir_expression
*const r0045
= less(r0041
, body
.constant(int(1)));
326 ir_if
*f0044
= new(mem_ctx
) ir_if(operand(r0045
).val
);
327 exec_list
*const f0044_parent_instructions
= body
.instructions
;
329 /* THEN INSTRUCTIONS */
330 body
.instructions
= &f0044
->then_instructions
;
332 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
335 body
.instructions
= f0044_parent_instructions
;
341 ir_expression
*const r0047
= sub(body
.constant(int(31)), r0041
);
342 ir_expression
*const r0048
= lequal(r0042
, r0047
);
343 ir_expression
*const r0049
= lshift(swizzle_x(r0036
), r0041
);
344 ir_expression
*const r004A
= lequal(r0049
, swizzle_y(r0037
));
345 ir_expression
*const r004B
= logic_and(r0048
, r004A
);
346 ir_if
*f0046
= new(mem_ctx
) ir_if(operand(r004B
).val
);
347 exec_list
*const f0046_parent_instructions
= body
.instructions
;
349 /* THEN INSTRUCTIONS */
350 body
.instructions
= &f0046
->then_instructions
;
352 ir_expression
*const r004C
= lshift(swizzle_x(r0036
), r0041
);
353 body
.emit(assign(r0037
, sub(swizzle_y(r0037
), r004C
), 0x02));
355 ir_expression
*const r004D
= lshift(body
.constant(1u), r0041
);
356 body
.emit(assign(r003B
, bit_or(swizzle_y(r003B
), r004D
), 0x02));
359 body
.instructions
= f0046_parent_instructions
;
364 body
.emit(assign(r0041
, add(r0041
, body
.constant(int(-1))), 0x01));
368 body
.instructions
= f0043_parent_instructions
;
372 ir_expression
*const r004F
= lequal(swizzle_x(r0036
), swizzle_y(r0037
));
373 ir_if
*f004E
= new(mem_ctx
) ir_if(operand(r004F
).val
);
374 exec_list
*const f004E_parent_instructions
= body
.instructions
;
376 /* THEN INSTRUCTIONS */
377 body
.instructions
= &f004E
->then_instructions
;
379 body
.emit(assign(r0037
, sub(swizzle_y(r0037
), swizzle_x(r0036
)), 0x02));
381 body
.emit(assign(r003B
, bit_or(swizzle_y(r003B
), body
.constant(1u)), 0x02));
384 body
.instructions
= f004E_parent_instructions
;
390 body
.instructions
= f003D_parent_instructions
;
395 ir_variable
*const r0050
= body
.make_temp(glsl_type::uint64_t_type
, "packUint2x32_retval");
396 body
.emit(assign(r0050
, expr(ir_unop_pack_uint_2x32
, r0036
), 0x01));
398 body
.emit(assign(r0039
, expr(ir_unop_pack_uint_2x32
, r0037
), 0x01));
400 body
.emit(assign(r0038
, body
.constant(int(31)), 0x01));
403 ir_loop
*f0051
= new(mem_ctx
) ir_loop();
404 exec_list
*const f0051_parent_instructions
= body
.instructions
;
406 body
.instructions
= &f0051
->body_instructions
;
409 ir_expression
*const r0053
= less(r0038
, body
.constant(int(1)));
410 ir_if
*f0052
= new(mem_ctx
) ir_if(operand(r0053
).val
);
411 exec_list
*const f0052_parent_instructions
= body
.instructions
;
413 /* THEN INSTRUCTIONS */
414 body
.instructions
= &f0052
->then_instructions
;
416 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
419 body
.instructions
= f0052_parent_instructions
;
425 ir_expression
*const r0055
= sub(body
.constant(int(63)), r0038
);
426 ir_expression
*const r0056
= lequal(r003A
, r0055
);
427 ir_expression
*const r0057
= lshift(r0050
, r0038
);
428 ir_expression
*const r0058
= lequal(r0057
, r0039
);
429 ir_expression
*const r0059
= logic_and(r0056
, r0058
);
430 ir_if
*f0054
= new(mem_ctx
) ir_if(operand(r0059
).val
);
431 exec_list
*const f0054_parent_instructions
= body
.instructions
;
433 /* THEN INSTRUCTIONS */
434 body
.instructions
= &f0054
->then_instructions
;
436 ir_expression
*const r005A
= lshift(r0050
, r0038
);
437 body
.emit(assign(r0039
, sub(r0039
, r005A
), 0x01));
439 ir_expression
*const r005B
= lshift(body
.constant(1u), r0038
);
440 body
.emit(assign(r003B
, bit_or(swizzle_x(r003B
), r005B
), 0x01));
443 body
.instructions
= f0054_parent_instructions
;
448 body
.emit(assign(r0038
, add(r0038
, body
.constant(int(-1))), 0x01));
452 body
.instructions
= f0051_parent_instructions
;
456 ir_expression
*const r005D
= lequal(r0050
, r0039
);
457 ir_if
*f005C
= new(mem_ctx
) ir_if(operand(r005D
).val
);
458 exec_list
*const f005C_parent_instructions
= body
.instructions
;
460 /* THEN INSTRUCTIONS */
461 body
.instructions
= &f005C
->then_instructions
;
463 body
.emit(assign(r0039
, sub(r0039
, r0050
), 0x01));
465 body
.emit(assign(r003B
, bit_or(swizzle_x(r003B
), body
.constant(1u)), 0x01));
468 body
.instructions
= f005C_parent_instructions
;
473 body
.emit(ret(r003B
));
475 sig
->replace_parameters(&sig_parameters
);
478 ir_function_signature
*
479 idiv64(void *mem_ctx
, builtin_available_predicate avail
)
481 ir_function_signature
*const sig
=
482 new(mem_ctx
) ir_function_signature(glsl_type::ivec2_type
, avail
);
483 ir_factory
body(&sig
->body
, mem_ctx
);
484 sig
->is_defined
= true;
486 exec_list sig_parameters
;
488 ir_variable
*const r005E
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "_n", ir_var_function_in
);
489 sig_parameters
.push_tail(r005E
);
490 ir_variable
*const r005F
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "_d", ir_var_function_in
);
491 sig_parameters
.push_tail(r005F
);
492 ir_variable
*const r0060
= new(mem_ctx
) ir_variable(glsl_type::bool_type
, "negate", ir_var_auto
);
494 ir_expression
*const r0061
= less(swizzle_y(r005E
), body
.constant(int(0)));
495 ir_expression
*const r0062
= less(swizzle_y(r005F
), body
.constant(int(0)));
496 body
.emit(assign(r0060
, nequal(r0061
, r0062
), 0x01));
498 ir_variable
*const r0063
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "n", ir_var_auto
);
500 ir_expression
*const r0064
= expr(ir_unop_pack_int_2x32
, r005E
);
501 ir_expression
*const r0065
= expr(ir_unop_abs
, r0064
);
502 ir_expression
*const r0066
= expr(ir_unop_i642u64
, r0065
);
503 body
.emit(assign(r0063
, expr(ir_unop_unpack_uint_2x32
, r0066
), 0x03));
505 ir_variable
*const r0067
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "d", ir_var_auto
);
507 ir_expression
*const r0068
= expr(ir_unop_pack_int_2x32
, r005F
);
508 ir_expression
*const r0069
= expr(ir_unop_abs
, r0068
);
509 ir_expression
*const r006A
= expr(ir_unop_i642u64
, r0069
);
510 body
.emit(assign(r0067
, expr(ir_unop_unpack_uint_2x32
, r006A
), 0x03));
512 ir_variable
*const r006B
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
514 ir_variable
*const r006C
= new(mem_ctx
) ir_variable(glsl_type::uint64_t_type
, "n64", ir_var_auto
);
516 ir_variable
*const r006D
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "log2_denom", ir_var_auto
);
518 ir_variable
*const r006E
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "quot", ir_var_auto
);
520 body
.emit(assign(r006E
, ir_constant::zero(mem_ctx
, glsl_type::uvec2_type
), 0x03));
522 ir_expression
*const r006F
= expr(ir_unop_find_msb
, swizzle_y(r0067
));
523 body
.emit(assign(r006D
, add(r006F
, body
.constant(int(32))), 0x01));
526 ir_expression
*const r0071
= equal(swizzle_y(r0067
), body
.constant(0u));
527 ir_expression
*const r0072
= gequal(swizzle_y(r0063
), swizzle_x(r0067
));
528 ir_expression
*const r0073
= logic_and(r0071
, r0072
);
529 ir_if
*f0070
= new(mem_ctx
) ir_if(operand(r0073
).val
);
530 exec_list
*const f0070_parent_instructions
= body
.instructions
;
532 /* THEN INSTRUCTIONS */
533 body
.instructions
= &f0070
->then_instructions
;
535 ir_variable
*const r0074
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
537 ir_variable
*const r0075
= body
.make_temp(glsl_type::int_type
, "findMSB_retval");
538 body
.emit(assign(r0075
, expr(ir_unop_find_msb
, swizzle_x(r0067
)), 0x01));
540 body
.emit(assign(r006D
, r0075
, 0x01));
542 body
.emit(assign(r0074
, body
.constant(int(31)), 0x01));
545 ir_loop
*f0076
= new(mem_ctx
) ir_loop();
546 exec_list
*const f0076_parent_instructions
= body
.instructions
;
548 body
.instructions
= &f0076
->body_instructions
;
551 ir_expression
*const r0078
= less(r0074
, body
.constant(int(1)));
552 ir_if
*f0077
= new(mem_ctx
) ir_if(operand(r0078
).val
);
553 exec_list
*const f0077_parent_instructions
= body
.instructions
;
555 /* THEN INSTRUCTIONS */
556 body
.instructions
= &f0077
->then_instructions
;
558 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
561 body
.instructions
= f0077_parent_instructions
;
567 ir_expression
*const r007A
= sub(body
.constant(int(31)), r0074
);
568 ir_expression
*const r007B
= lequal(r0075
, r007A
);
569 ir_expression
*const r007C
= lshift(swizzle_x(r0067
), r0074
);
570 ir_expression
*const r007D
= lequal(r007C
, swizzle_y(r0063
));
571 ir_expression
*const r007E
= logic_and(r007B
, r007D
);
572 ir_if
*f0079
= new(mem_ctx
) ir_if(operand(r007E
).val
);
573 exec_list
*const f0079_parent_instructions
= body
.instructions
;
575 /* THEN INSTRUCTIONS */
576 body
.instructions
= &f0079
->then_instructions
;
578 ir_expression
*const r007F
= lshift(swizzle_x(r0067
), r0074
);
579 body
.emit(assign(r0063
, sub(swizzle_y(r0063
), r007F
), 0x02));
581 ir_expression
*const r0080
= lshift(body
.constant(1u), r0074
);
582 body
.emit(assign(r006E
, bit_or(swizzle_y(r006E
), r0080
), 0x02));
585 body
.instructions
= f0079_parent_instructions
;
590 body
.emit(assign(r0074
, add(r0074
, body
.constant(int(-1))), 0x01));
594 body
.instructions
= f0076_parent_instructions
;
598 ir_expression
*const r0082
= lequal(swizzle_x(r0067
), swizzle_y(r0063
));
599 ir_if
*f0081
= new(mem_ctx
) ir_if(operand(r0082
).val
);
600 exec_list
*const f0081_parent_instructions
= body
.instructions
;
602 /* THEN INSTRUCTIONS */
603 body
.instructions
= &f0081
->then_instructions
;
605 body
.emit(assign(r0063
, sub(swizzle_y(r0063
), swizzle_x(r0067
)), 0x02));
607 body
.emit(assign(r006E
, bit_or(swizzle_y(r006E
), body
.constant(1u)), 0x02));
610 body
.instructions
= f0081_parent_instructions
;
616 body
.instructions
= f0070_parent_instructions
;
621 ir_variable
*const r0083
= body
.make_temp(glsl_type::uint64_t_type
, "packUint2x32_retval");
622 body
.emit(assign(r0083
, expr(ir_unop_pack_uint_2x32
, r0067
), 0x01));
624 body
.emit(assign(r006C
, expr(ir_unop_pack_uint_2x32
, r0063
), 0x01));
626 body
.emit(assign(r006B
, body
.constant(int(31)), 0x01));
629 ir_loop
*f0084
= new(mem_ctx
) ir_loop();
630 exec_list
*const f0084_parent_instructions
= body
.instructions
;
632 body
.instructions
= &f0084
->body_instructions
;
635 ir_expression
*const r0086
= less(r006B
, body
.constant(int(1)));
636 ir_if
*f0085
= new(mem_ctx
) ir_if(operand(r0086
).val
);
637 exec_list
*const f0085_parent_instructions
= body
.instructions
;
639 /* THEN INSTRUCTIONS */
640 body
.instructions
= &f0085
->then_instructions
;
642 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
645 body
.instructions
= f0085_parent_instructions
;
651 ir_expression
*const r0088
= sub(body
.constant(int(63)), r006B
);
652 ir_expression
*const r0089
= lequal(r006D
, r0088
);
653 ir_expression
*const r008A
= lshift(r0083
, r006B
);
654 ir_expression
*const r008B
= lequal(r008A
, r006C
);
655 ir_expression
*const r008C
= logic_and(r0089
, r008B
);
656 ir_if
*f0087
= new(mem_ctx
) ir_if(operand(r008C
).val
);
657 exec_list
*const f0087_parent_instructions
= body
.instructions
;
659 /* THEN INSTRUCTIONS */
660 body
.instructions
= &f0087
->then_instructions
;
662 ir_expression
*const r008D
= lshift(r0083
, r006B
);
663 body
.emit(assign(r006C
, sub(r006C
, r008D
), 0x01));
665 ir_expression
*const r008E
= lshift(body
.constant(1u), r006B
);
666 body
.emit(assign(r006E
, bit_or(swizzle_x(r006E
), r008E
), 0x01));
669 body
.instructions
= f0087_parent_instructions
;
674 body
.emit(assign(r006B
, add(r006B
, body
.constant(int(-1))), 0x01));
678 body
.instructions
= f0084_parent_instructions
;
682 ir_expression
*const r0090
= lequal(r0083
, r006C
);
683 ir_if
*f008F
= new(mem_ctx
) ir_if(operand(r0090
).val
);
684 exec_list
*const f008F_parent_instructions
= body
.instructions
;
686 /* THEN INSTRUCTIONS */
687 body
.instructions
= &f008F
->then_instructions
;
689 body
.emit(assign(r006C
, sub(r006C
, r0083
), 0x01));
691 body
.emit(assign(r006E
, bit_or(swizzle_x(r006E
), body
.constant(1u)), 0x01));
694 body
.instructions
= f008F_parent_instructions
;
699 ir_variable
*const r0091
= body
.make_temp(glsl_type::ivec2_type
, "conditional_tmp");
701 ir_if
*f0092
= new(mem_ctx
) ir_if(operand(r0060
).val
);
702 exec_list
*const f0092_parent_instructions
= body
.instructions
;
704 /* THEN INSTRUCTIONS */
705 body
.instructions
= &f0092
->then_instructions
;
707 ir_expression
*const r0093
= expr(ir_unop_pack_uint_2x32
, r006E
);
708 ir_expression
*const r0094
= expr(ir_unop_u642i64
, r0093
);
709 ir_expression
*const r0095
= neg(r0094
);
710 body
.emit(assign(r0091
, expr(ir_unop_unpack_int_2x32
, r0095
), 0x03));
713 /* ELSE INSTRUCTIONS */
714 body
.instructions
= &f0092
->else_instructions
;
716 body
.emit(assign(r0091
, expr(ir_unop_u2i
, r006E
), 0x03));
719 body
.instructions
= f0092_parent_instructions
;
724 body
.emit(ret(r0091
));
726 sig
->replace_parameters(&sig_parameters
);