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
= body
.make_temp(glsl_type::uvec2_type
, "n");
283 body
.emit(assign(r0037
, r0035
, 0x03));
285 ir_variable
*const r0038
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
287 ir_variable
*const r0039
= new(mem_ctx
) ir_variable(glsl_type::uint64_t_type
, "n64", ir_var_auto
);
289 ir_variable
*const r003A
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "log2_denom", ir_var_auto
);
291 ir_variable
*const r003B
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "quot", ir_var_auto
);
293 body
.emit(assign(r003B
, ir_constant::zero(mem_ctx
, glsl_type::uvec2_type
), 0x03));
295 ir_expression
*const r003C
= expr(ir_unop_find_msb
, swizzle_y(r0036
));
296 body
.emit(assign(r003A
, add(r003C
, body
.constant(int(32))), 0x01));
299 ir_expression
*const r003E
= equal(swizzle_y(r0036
), body
.constant(0u));
300 ir_expression
*const r003F
= gequal(swizzle_y(r0035
), swizzle_x(r0036
));
301 ir_expression
*const r0040
= logic_and(r003E
, r003F
);
302 ir_if
*f003D
= new(mem_ctx
) ir_if(operand(r0040
).val
);
303 exec_list
*const f003D_parent_instructions
= body
.instructions
;
305 /* THEN INSTRUCTIONS */
306 body
.instructions
= &f003D
->then_instructions
;
308 ir_variable
*const r0041
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
310 ir_variable
*const r0042
= body
.make_temp(glsl_type::int_type
, "findMSB_retval");
311 body
.emit(assign(r0042
, expr(ir_unop_find_msb
, swizzle_x(r0036
)), 0x01));
313 body
.emit(assign(r003A
, r0042
, 0x01));
315 body
.emit(assign(r0041
, body
.constant(int(31)), 0x01));
318 ir_loop
*f0043
= new(mem_ctx
) ir_loop();
319 exec_list
*const f0043_parent_instructions
= body
.instructions
;
321 body
.instructions
= &f0043
->body_instructions
;
324 ir_expression
*const r0045
= less(r0041
, body
.constant(int(1)));
325 ir_if
*f0044
= new(mem_ctx
) ir_if(operand(r0045
).val
);
326 exec_list
*const f0044_parent_instructions
= body
.instructions
;
328 /* THEN INSTRUCTIONS */
329 body
.instructions
= &f0044
->then_instructions
;
331 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
334 body
.instructions
= f0044_parent_instructions
;
340 ir_expression
*const r0047
= sub(body
.constant(int(31)), r0041
);
341 ir_expression
*const r0048
= lequal(r0042
, r0047
);
342 ir_expression
*const r0049
= lshift(swizzle_x(r0036
), r0041
);
343 ir_expression
*const r004A
= lequal(r0049
, swizzle_y(r0037
));
344 ir_expression
*const r004B
= logic_and(r0048
, r004A
);
345 ir_if
*f0046
= new(mem_ctx
) ir_if(operand(r004B
).val
);
346 exec_list
*const f0046_parent_instructions
= body
.instructions
;
348 /* THEN INSTRUCTIONS */
349 body
.instructions
= &f0046
->then_instructions
;
351 ir_expression
*const r004C
= lshift(swizzle_x(r0036
), r0041
);
352 body
.emit(assign(r0037
, sub(swizzle_y(r0037
), r004C
), 0x02));
354 ir_expression
*const r004D
= lshift(body
.constant(1u), r0041
);
355 body
.emit(assign(r003B
, bit_or(swizzle_y(r003B
), r004D
), 0x02));
358 body
.instructions
= f0046_parent_instructions
;
363 body
.emit(assign(r0041
, add(r0041
, body
.constant(int(-1))), 0x01));
367 body
.instructions
= f0043_parent_instructions
;
371 ir_expression
*const r004F
= lequal(swizzle_x(r0036
), swizzle_y(r0037
));
372 ir_if
*f004E
= new(mem_ctx
) ir_if(operand(r004F
).val
);
373 exec_list
*const f004E_parent_instructions
= body
.instructions
;
375 /* THEN INSTRUCTIONS */
376 body
.instructions
= &f004E
->then_instructions
;
378 body
.emit(assign(r0037
, sub(swizzle_y(r0037
), swizzle_x(r0036
)), 0x02));
380 body
.emit(assign(r003B
, bit_or(swizzle_y(r003B
), body
.constant(1u)), 0x02));
383 body
.instructions
= f004E_parent_instructions
;
389 body
.instructions
= f003D_parent_instructions
;
394 ir_variable
*const r0050
= body
.make_temp(glsl_type::uint64_t_type
, "packUint2x32_retval");
395 body
.emit(assign(r0050
, expr(ir_unop_pack_uint_2x32
, r0036
), 0x01));
397 body
.emit(assign(r0039
, expr(ir_unop_pack_uint_2x32
, r0037
), 0x01));
399 body
.emit(assign(r0038
, body
.constant(int(31)), 0x01));
402 ir_loop
*f0051
= new(mem_ctx
) ir_loop();
403 exec_list
*const f0051_parent_instructions
= body
.instructions
;
405 body
.instructions
= &f0051
->body_instructions
;
408 ir_expression
*const r0053
= less(r0038
, body
.constant(int(1)));
409 ir_if
*f0052
= new(mem_ctx
) ir_if(operand(r0053
).val
);
410 exec_list
*const f0052_parent_instructions
= body
.instructions
;
412 /* THEN INSTRUCTIONS */
413 body
.instructions
= &f0052
->then_instructions
;
415 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
418 body
.instructions
= f0052_parent_instructions
;
424 ir_expression
*const r0055
= sub(body
.constant(int(63)), r0038
);
425 ir_expression
*const r0056
= lequal(r003A
, r0055
);
426 ir_expression
*const r0057
= lshift(r0050
, r0038
);
427 ir_expression
*const r0058
= lequal(r0057
, r0039
);
428 ir_expression
*const r0059
= logic_and(r0056
, r0058
);
429 ir_if
*f0054
= new(mem_ctx
) ir_if(operand(r0059
).val
);
430 exec_list
*const f0054_parent_instructions
= body
.instructions
;
432 /* THEN INSTRUCTIONS */
433 body
.instructions
= &f0054
->then_instructions
;
435 ir_expression
*const r005A
= lshift(r0050
, r0038
);
436 body
.emit(assign(r0039
, sub(r0039
, r005A
), 0x01));
438 ir_expression
*const r005B
= lshift(body
.constant(1u), r0038
);
439 body
.emit(assign(r003B
, bit_or(swizzle_x(r003B
), r005B
), 0x01));
442 body
.instructions
= f0054_parent_instructions
;
447 body
.emit(assign(r0038
, add(r0038
, body
.constant(int(-1))), 0x01));
451 body
.instructions
= f0051_parent_instructions
;
455 ir_expression
*const r005D
= lequal(r0050
, r0039
);
456 ir_if
*f005C
= new(mem_ctx
) ir_if(operand(r005D
).val
);
457 exec_list
*const f005C_parent_instructions
= body
.instructions
;
459 /* THEN INSTRUCTIONS */
460 body
.instructions
= &f005C
->then_instructions
;
462 body
.emit(assign(r0039
, sub(r0039
, r0050
), 0x01));
464 body
.emit(assign(r003B
, bit_or(swizzle_x(r003B
), body
.constant(1u)), 0x01));
467 body
.instructions
= f005C_parent_instructions
;
472 body
.emit(ret(r003B
));
474 sig
->replace_parameters(&sig_parameters
);
477 ir_function_signature
*
478 idiv64(void *mem_ctx
, builtin_available_predicate avail
)
480 ir_function_signature
*const sig
=
481 new(mem_ctx
) ir_function_signature(glsl_type::ivec2_type
, avail
);
482 ir_factory
body(&sig
->body
, mem_ctx
);
483 sig
->is_defined
= true;
485 exec_list sig_parameters
;
487 ir_variable
*const r005E
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "_n", ir_var_function_in
);
488 sig_parameters
.push_tail(r005E
);
489 ir_variable
*const r005F
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "_d", ir_var_function_in
);
490 sig_parameters
.push_tail(r005F
);
491 ir_variable
*const r0060
= new(mem_ctx
) ir_variable(glsl_type::bool_type
, "negate", ir_var_auto
);
493 ir_expression
*const r0061
= less(swizzle_y(r005E
), body
.constant(int(0)));
494 ir_expression
*const r0062
= less(swizzle_y(r005F
), body
.constant(int(0)));
495 body
.emit(assign(r0060
, nequal(r0061
, r0062
), 0x01));
497 ir_variable
*const r0063
= body
.make_temp(glsl_type::uvec2_type
, "n");
498 ir_expression
*const r0064
= expr(ir_unop_pack_int_2x32
, r005E
);
499 ir_expression
*const r0065
= expr(ir_unop_abs
, r0064
);
500 ir_expression
*const r0066
= expr(ir_unop_i642u64
, r0065
);
501 body
.emit(assign(r0063
, expr(ir_unop_unpack_uint_2x32
, r0066
), 0x03));
503 ir_variable
*const r0067
= body
.make_temp(glsl_type::uvec2_type
, "d");
504 ir_expression
*const r0068
= expr(ir_unop_pack_int_2x32
, r005F
);
505 ir_expression
*const r0069
= expr(ir_unop_abs
, r0068
);
506 ir_expression
*const r006A
= expr(ir_unop_i642u64
, r0069
);
507 body
.emit(assign(r0067
, expr(ir_unop_unpack_uint_2x32
, r006A
), 0x03));
509 ir_variable
*const r006B
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
511 ir_variable
*const r006C
= new(mem_ctx
) ir_variable(glsl_type::uint64_t_type
, "n64", ir_var_auto
);
513 ir_variable
*const r006D
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "log2_denom", ir_var_auto
);
515 ir_variable
*const r006E
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "quot", ir_var_auto
);
517 body
.emit(assign(r006E
, ir_constant::zero(mem_ctx
, glsl_type::uvec2_type
), 0x03));
519 ir_expression
*const r006F
= expr(ir_unop_find_msb
, swizzle_y(r0067
));
520 body
.emit(assign(r006D
, add(r006F
, body
.constant(int(32))), 0x01));
523 ir_expression
*const r0071
= equal(swizzle_y(r0067
), body
.constant(0u));
524 ir_expression
*const r0072
= gequal(swizzle_y(r0063
), swizzle_x(r0067
));
525 ir_expression
*const r0073
= logic_and(r0071
, r0072
);
526 ir_if
*f0070
= new(mem_ctx
) ir_if(operand(r0073
).val
);
527 exec_list
*const f0070_parent_instructions
= body
.instructions
;
529 /* THEN INSTRUCTIONS */
530 body
.instructions
= &f0070
->then_instructions
;
532 ir_variable
*const r0074
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
534 ir_variable
*const r0075
= body
.make_temp(glsl_type::int_type
, "findMSB_retval");
535 body
.emit(assign(r0075
, expr(ir_unop_find_msb
, swizzle_x(r0067
)), 0x01));
537 body
.emit(assign(r006D
, r0075
, 0x01));
539 body
.emit(assign(r0074
, body
.constant(int(31)), 0x01));
542 ir_loop
*f0076
= new(mem_ctx
) ir_loop();
543 exec_list
*const f0076_parent_instructions
= body
.instructions
;
545 body
.instructions
= &f0076
->body_instructions
;
548 ir_expression
*const r0078
= less(r0074
, body
.constant(int(1)));
549 ir_if
*f0077
= new(mem_ctx
) ir_if(operand(r0078
).val
);
550 exec_list
*const f0077_parent_instructions
= body
.instructions
;
552 /* THEN INSTRUCTIONS */
553 body
.instructions
= &f0077
->then_instructions
;
555 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
558 body
.instructions
= f0077_parent_instructions
;
564 ir_expression
*const r007A
= sub(body
.constant(int(31)), r0074
);
565 ir_expression
*const r007B
= lequal(r0075
, r007A
);
566 ir_expression
*const r007C
= lshift(swizzle_x(r0067
), r0074
);
567 ir_expression
*const r007D
= lequal(r007C
, swizzle_y(r0063
));
568 ir_expression
*const r007E
= logic_and(r007B
, r007D
);
569 ir_if
*f0079
= new(mem_ctx
) ir_if(operand(r007E
).val
);
570 exec_list
*const f0079_parent_instructions
= body
.instructions
;
572 /* THEN INSTRUCTIONS */
573 body
.instructions
= &f0079
->then_instructions
;
575 ir_expression
*const r007F
= lshift(swizzle_x(r0067
), r0074
);
576 body
.emit(assign(r0063
, sub(swizzle_y(r0063
), r007F
), 0x02));
578 ir_expression
*const r0080
= lshift(body
.constant(1u), r0074
);
579 body
.emit(assign(r006E
, bit_or(swizzle_y(r006E
), r0080
), 0x02));
582 body
.instructions
= f0079_parent_instructions
;
587 body
.emit(assign(r0074
, add(r0074
, body
.constant(int(-1))), 0x01));
591 body
.instructions
= f0076_parent_instructions
;
595 ir_expression
*const r0082
= lequal(swizzle_x(r0067
), swizzle_y(r0063
));
596 ir_if
*f0081
= new(mem_ctx
) ir_if(operand(r0082
).val
);
597 exec_list
*const f0081_parent_instructions
= body
.instructions
;
599 /* THEN INSTRUCTIONS */
600 body
.instructions
= &f0081
->then_instructions
;
602 body
.emit(assign(r0063
, sub(swizzle_y(r0063
), swizzle_x(r0067
)), 0x02));
604 body
.emit(assign(r006E
, bit_or(swizzle_y(r006E
), body
.constant(1u)), 0x02));
607 body
.instructions
= f0081_parent_instructions
;
613 body
.instructions
= f0070_parent_instructions
;
618 ir_variable
*const r0083
= body
.make_temp(glsl_type::uint64_t_type
, "packUint2x32_retval");
619 body
.emit(assign(r0083
, expr(ir_unop_pack_uint_2x32
, r0067
), 0x01));
621 body
.emit(assign(r006C
, expr(ir_unop_pack_uint_2x32
, r0063
), 0x01));
623 body
.emit(assign(r006B
, body
.constant(int(31)), 0x01));
626 ir_loop
*f0084
= new(mem_ctx
) ir_loop();
627 exec_list
*const f0084_parent_instructions
= body
.instructions
;
629 body
.instructions
= &f0084
->body_instructions
;
632 ir_expression
*const r0086
= less(r006B
, body
.constant(int(1)));
633 ir_if
*f0085
= new(mem_ctx
) ir_if(operand(r0086
).val
);
634 exec_list
*const f0085_parent_instructions
= body
.instructions
;
636 /* THEN INSTRUCTIONS */
637 body
.instructions
= &f0085
->then_instructions
;
639 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
642 body
.instructions
= f0085_parent_instructions
;
648 ir_expression
*const r0088
= sub(body
.constant(int(63)), r006B
);
649 ir_expression
*const r0089
= lequal(r006D
, r0088
);
650 ir_expression
*const r008A
= lshift(r0083
, r006B
);
651 ir_expression
*const r008B
= lequal(r008A
, r006C
);
652 ir_expression
*const r008C
= logic_and(r0089
, r008B
);
653 ir_if
*f0087
= new(mem_ctx
) ir_if(operand(r008C
).val
);
654 exec_list
*const f0087_parent_instructions
= body
.instructions
;
656 /* THEN INSTRUCTIONS */
657 body
.instructions
= &f0087
->then_instructions
;
659 ir_expression
*const r008D
= lshift(r0083
, r006B
);
660 body
.emit(assign(r006C
, sub(r006C
, r008D
), 0x01));
662 ir_expression
*const r008E
= lshift(body
.constant(1u), r006B
);
663 body
.emit(assign(r006E
, bit_or(swizzle_x(r006E
), r008E
), 0x01));
666 body
.instructions
= f0087_parent_instructions
;
671 body
.emit(assign(r006B
, add(r006B
, body
.constant(int(-1))), 0x01));
675 body
.instructions
= f0084_parent_instructions
;
679 ir_expression
*const r0090
= lequal(r0083
, r006C
);
680 ir_if
*f008F
= new(mem_ctx
) ir_if(operand(r0090
).val
);
681 exec_list
*const f008F_parent_instructions
= body
.instructions
;
683 /* THEN INSTRUCTIONS */
684 body
.instructions
= &f008F
->then_instructions
;
686 body
.emit(assign(r006C
, sub(r006C
, r0083
), 0x01));
688 body
.emit(assign(r006E
, bit_or(swizzle_x(r006E
), body
.constant(1u)), 0x01));
691 body
.instructions
= f008F_parent_instructions
;
696 ir_variable
*const r0091
= body
.make_temp(glsl_type::ivec2_type
, "conditional_tmp");
698 ir_if
*f0092
= new(mem_ctx
) ir_if(operand(r0060
).val
);
699 exec_list
*const f0092_parent_instructions
= body
.instructions
;
701 /* THEN INSTRUCTIONS */
702 body
.instructions
= &f0092
->then_instructions
;
704 ir_expression
*const r0093
= expr(ir_unop_pack_uint_2x32
, r006E
);
705 ir_expression
*const r0094
= expr(ir_unop_u642i64
, r0093
);
706 ir_expression
*const r0095
= neg(r0094
);
707 body
.emit(assign(r0091
, expr(ir_unop_unpack_int_2x32
, r0095
), 0x03));
710 /* ELSE INSTRUCTIONS */
711 body
.instructions
= &f0092
->else_instructions
;
713 body
.emit(assign(r0091
, expr(ir_unop_u2i
, r006E
), 0x03));
716 body
.instructions
= f0092_parent_instructions
;
721 body
.emit(ret(r0091
));
723 sig
->replace_parameters(&sig_parameters
);
726 ir_function_signature
*
727 umod64(void *mem_ctx
, builtin_available_predicate avail
)
729 ir_function_signature
*const sig
=
730 new(mem_ctx
) ir_function_signature(glsl_type::uvec2_type
, avail
);
731 ir_factory
body(&sig
->body
, mem_ctx
);
732 sig
->is_defined
= true;
734 exec_list sig_parameters
;
736 ir_variable
*const r0096
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "n", ir_var_function_in
);
737 sig_parameters
.push_tail(r0096
);
738 ir_variable
*const r0097
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "d", ir_var_function_in
);
739 sig_parameters
.push_tail(r0097
);
740 ir_variable
*const r0098
= body
.make_temp(glsl_type::uvec2_type
, "n");
741 body
.emit(assign(r0098
, r0096
, 0x03));
743 ir_variable
*const r0099
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
745 ir_variable
*const r009A
= new(mem_ctx
) ir_variable(glsl_type::uint64_t_type
, "n64", ir_var_auto
);
747 ir_variable
*const r009B
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "log2_denom", ir_var_auto
);
749 ir_variable
*const r009C
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "quot", ir_var_auto
);
751 body
.emit(assign(r009C
, ir_constant::zero(mem_ctx
, glsl_type::uvec2_type
), 0x03));
753 ir_expression
*const r009D
= expr(ir_unop_find_msb
, swizzle_y(r0097
));
754 body
.emit(assign(r009B
, add(r009D
, body
.constant(int(32))), 0x01));
757 ir_expression
*const r009F
= equal(swizzle_y(r0097
), body
.constant(0u));
758 ir_expression
*const r00A0
= gequal(swizzle_y(r0096
), swizzle_x(r0097
));
759 ir_expression
*const r00A1
= logic_and(r009F
, r00A0
);
760 ir_if
*f009E
= new(mem_ctx
) ir_if(operand(r00A1
).val
);
761 exec_list
*const f009E_parent_instructions
= body
.instructions
;
763 /* THEN INSTRUCTIONS */
764 body
.instructions
= &f009E
->then_instructions
;
766 ir_variable
*const r00A2
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
768 ir_variable
*const r00A3
= body
.make_temp(glsl_type::int_type
, "findMSB_retval");
769 body
.emit(assign(r00A3
, expr(ir_unop_find_msb
, swizzle_x(r0097
)), 0x01));
771 body
.emit(assign(r009B
, r00A3
, 0x01));
773 body
.emit(assign(r00A2
, body
.constant(int(31)), 0x01));
776 ir_loop
*f00A4
= new(mem_ctx
) ir_loop();
777 exec_list
*const f00A4_parent_instructions
= body
.instructions
;
779 body
.instructions
= &f00A4
->body_instructions
;
782 ir_expression
*const r00A6
= less(r00A2
, body
.constant(int(1)));
783 ir_if
*f00A5
= new(mem_ctx
) ir_if(operand(r00A6
).val
);
784 exec_list
*const f00A5_parent_instructions
= body
.instructions
;
786 /* THEN INSTRUCTIONS */
787 body
.instructions
= &f00A5
->then_instructions
;
789 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
792 body
.instructions
= f00A5_parent_instructions
;
798 ir_expression
*const r00A8
= sub(body
.constant(int(31)), r00A2
);
799 ir_expression
*const r00A9
= lequal(r00A3
, r00A8
);
800 ir_expression
*const r00AA
= lshift(swizzle_x(r0097
), r00A2
);
801 ir_expression
*const r00AB
= lequal(r00AA
, swizzle_y(r0098
));
802 ir_expression
*const r00AC
= logic_and(r00A9
, r00AB
);
803 ir_if
*f00A7
= new(mem_ctx
) ir_if(operand(r00AC
).val
);
804 exec_list
*const f00A7_parent_instructions
= body
.instructions
;
806 /* THEN INSTRUCTIONS */
807 body
.instructions
= &f00A7
->then_instructions
;
809 ir_expression
*const r00AD
= lshift(swizzle_x(r0097
), r00A2
);
810 body
.emit(assign(r0098
, sub(swizzle_y(r0098
), r00AD
), 0x02));
812 ir_expression
*const r00AE
= lshift(body
.constant(1u), r00A2
);
813 body
.emit(assign(r009C
, bit_or(swizzle_y(r009C
), r00AE
), 0x02));
816 body
.instructions
= f00A7_parent_instructions
;
821 body
.emit(assign(r00A2
, add(r00A2
, body
.constant(int(-1))), 0x01));
825 body
.instructions
= f00A4_parent_instructions
;
829 ir_expression
*const r00B0
= lequal(swizzle_x(r0097
), swizzle_y(r0098
));
830 ir_if
*f00AF
= new(mem_ctx
) ir_if(operand(r00B0
).val
);
831 exec_list
*const f00AF_parent_instructions
= body
.instructions
;
833 /* THEN INSTRUCTIONS */
834 body
.instructions
= &f00AF
->then_instructions
;
836 body
.emit(assign(r0098
, sub(swizzle_y(r0098
), swizzle_x(r0097
)), 0x02));
838 body
.emit(assign(r009C
, bit_or(swizzle_y(r009C
), body
.constant(1u)), 0x02));
841 body
.instructions
= f00AF_parent_instructions
;
847 body
.instructions
= f009E_parent_instructions
;
852 ir_variable
*const r00B1
= body
.make_temp(glsl_type::uint64_t_type
, "packUint2x32_retval");
853 body
.emit(assign(r00B1
, expr(ir_unop_pack_uint_2x32
, r0097
), 0x01));
855 body
.emit(assign(r009A
, expr(ir_unop_pack_uint_2x32
, r0098
), 0x01));
857 body
.emit(assign(r0099
, body
.constant(int(31)), 0x01));
860 ir_loop
*f00B2
= new(mem_ctx
) ir_loop();
861 exec_list
*const f00B2_parent_instructions
= body
.instructions
;
863 body
.instructions
= &f00B2
->body_instructions
;
866 ir_expression
*const r00B4
= less(r0099
, body
.constant(int(1)));
867 ir_if
*f00B3
= new(mem_ctx
) ir_if(operand(r00B4
).val
);
868 exec_list
*const f00B3_parent_instructions
= body
.instructions
;
870 /* THEN INSTRUCTIONS */
871 body
.instructions
= &f00B3
->then_instructions
;
873 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
876 body
.instructions
= f00B3_parent_instructions
;
882 ir_expression
*const r00B6
= sub(body
.constant(int(63)), r0099
);
883 ir_expression
*const r00B7
= lequal(r009B
, r00B6
);
884 ir_expression
*const r00B8
= lshift(r00B1
, r0099
);
885 ir_expression
*const r00B9
= lequal(r00B8
, r009A
);
886 ir_expression
*const r00BA
= logic_and(r00B7
, r00B9
);
887 ir_if
*f00B5
= new(mem_ctx
) ir_if(operand(r00BA
).val
);
888 exec_list
*const f00B5_parent_instructions
= body
.instructions
;
890 /* THEN INSTRUCTIONS */
891 body
.instructions
= &f00B5
->then_instructions
;
893 ir_expression
*const r00BB
= lshift(r00B1
, r0099
);
894 body
.emit(assign(r009A
, sub(r009A
, r00BB
), 0x01));
896 ir_expression
*const r00BC
= lshift(body
.constant(1u), r0099
);
897 body
.emit(assign(r009C
, bit_or(swizzle_x(r009C
), r00BC
), 0x01));
900 body
.instructions
= f00B5_parent_instructions
;
905 body
.emit(assign(r0099
, add(r0099
, body
.constant(int(-1))), 0x01));
909 body
.instructions
= f00B2_parent_instructions
;
913 ir_expression
*const r00BE
= lequal(r00B1
, r009A
);
914 ir_if
*f00BD
= new(mem_ctx
) ir_if(operand(r00BE
).val
);
915 exec_list
*const f00BD_parent_instructions
= body
.instructions
;
917 /* THEN INSTRUCTIONS */
918 body
.instructions
= &f00BD
->then_instructions
;
920 body
.emit(assign(r009A
, sub(r009A
, r00B1
), 0x01));
922 body
.emit(assign(r009C
, bit_or(swizzle_x(r009C
), body
.constant(1u)), 0x01));
925 body
.instructions
= f00BD_parent_instructions
;
930 ir_variable
*const r00BF
= body
.make_temp(glsl_type::uvec4_type
, "vec_ctor");
931 body
.emit(assign(r00BF
, r009C
, 0x03));
933 body
.emit(assign(r00BF
, expr(ir_unop_unpack_uint_2x32
, r009A
), 0x0c));
935 ir_swizzle
*const r00C0
= swizzle(r00BF
, MAKE_SWIZZLE4(SWIZZLE_Z
, SWIZZLE_W
, SWIZZLE_X
, SWIZZLE_X
), 2);
936 body
.emit(ret(r00C0
));
938 sig
->replace_parameters(&sig_parameters
);
941 ir_function_signature
*
942 imod64(void *mem_ctx
, builtin_available_predicate avail
)
944 ir_function_signature
*const sig
=
945 new(mem_ctx
) ir_function_signature(glsl_type::ivec2_type
, avail
);
946 ir_factory
body(&sig
->body
, mem_ctx
);
947 sig
->is_defined
= true;
949 exec_list sig_parameters
;
951 ir_variable
*const r00C1
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "_n", ir_var_function_in
);
952 sig_parameters
.push_tail(r00C1
);
953 ir_variable
*const r00C2
= new(mem_ctx
) ir_variable(glsl_type::ivec2_type
, "_d", ir_var_function_in
);
954 sig_parameters
.push_tail(r00C2
);
955 ir_variable
*const r00C3
= new(mem_ctx
) ir_variable(glsl_type::bool_type
, "negate", ir_var_auto
);
957 ir_expression
*const r00C4
= less(swizzle_y(r00C1
), body
.constant(int(0)));
958 ir_expression
*const r00C5
= less(swizzle_y(r00C2
), body
.constant(int(0)));
959 body
.emit(assign(r00C3
, nequal(r00C4
, r00C5
), 0x01));
961 ir_variable
*const r00C6
= body
.make_temp(glsl_type::uvec2_type
, "n");
962 ir_expression
*const r00C7
= expr(ir_unop_pack_int_2x32
, r00C1
);
963 ir_expression
*const r00C8
= expr(ir_unop_abs
, r00C7
);
964 ir_expression
*const r00C9
= expr(ir_unop_i642u64
, r00C8
);
965 body
.emit(assign(r00C6
, expr(ir_unop_unpack_uint_2x32
, r00C9
), 0x03));
967 ir_variable
*const r00CA
= body
.make_temp(glsl_type::uvec2_type
, "d");
968 ir_expression
*const r00CB
= expr(ir_unop_pack_int_2x32
, r00C2
);
969 ir_expression
*const r00CC
= expr(ir_unop_abs
, r00CB
);
970 ir_expression
*const r00CD
= expr(ir_unop_i642u64
, r00CC
);
971 body
.emit(assign(r00CA
, expr(ir_unop_unpack_uint_2x32
, r00CD
), 0x03));
973 ir_variable
*const r00CE
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
975 ir_variable
*const r00CF
= new(mem_ctx
) ir_variable(glsl_type::uint64_t_type
, "n64", ir_var_auto
);
977 ir_variable
*const r00D0
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "log2_denom", ir_var_auto
);
979 ir_variable
*const r00D1
= new(mem_ctx
) ir_variable(glsl_type::uvec2_type
, "quot", ir_var_auto
);
981 body
.emit(assign(r00D1
, ir_constant::zero(mem_ctx
, glsl_type::uvec2_type
), 0x03));
983 ir_expression
*const r00D2
= expr(ir_unop_find_msb
, swizzle_y(r00CA
));
984 body
.emit(assign(r00D0
, add(r00D2
, body
.constant(int(32))), 0x01));
987 ir_expression
*const r00D4
= equal(swizzle_y(r00CA
), body
.constant(0u));
988 ir_expression
*const r00D5
= gequal(swizzle_y(r00C6
), swizzle_x(r00CA
));
989 ir_expression
*const r00D6
= logic_and(r00D4
, r00D5
);
990 ir_if
*f00D3
= new(mem_ctx
) ir_if(operand(r00D6
).val
);
991 exec_list
*const f00D3_parent_instructions
= body
.instructions
;
993 /* THEN INSTRUCTIONS */
994 body
.instructions
= &f00D3
->then_instructions
;
996 ir_variable
*const r00D7
= new(mem_ctx
) ir_variable(glsl_type::int_type
, "i", ir_var_auto
);
998 ir_variable
*const r00D8
= body
.make_temp(glsl_type::int_type
, "findMSB_retval");
999 body
.emit(assign(r00D8
, expr(ir_unop_find_msb
, swizzle_x(r00CA
)), 0x01));
1001 body
.emit(assign(r00D0
, r00D8
, 0x01));
1003 body
.emit(assign(r00D7
, body
.constant(int(31)), 0x01));
1006 ir_loop
*f00D9
= new(mem_ctx
) ir_loop();
1007 exec_list
*const f00D9_parent_instructions
= body
.instructions
;
1009 body
.instructions
= &f00D9
->body_instructions
;
1012 ir_expression
*const r00DB
= less(r00D7
, body
.constant(int(1)));
1013 ir_if
*f00DA
= new(mem_ctx
) ir_if(operand(r00DB
).val
);
1014 exec_list
*const f00DA_parent_instructions
= body
.instructions
;
1016 /* THEN INSTRUCTIONS */
1017 body
.instructions
= &f00DA
->then_instructions
;
1019 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
1022 body
.instructions
= f00DA_parent_instructions
;
1028 ir_expression
*const r00DD
= sub(body
.constant(int(31)), r00D7
);
1029 ir_expression
*const r00DE
= lequal(r00D8
, r00DD
);
1030 ir_expression
*const r00DF
= lshift(swizzle_x(r00CA
), r00D7
);
1031 ir_expression
*const r00E0
= lequal(r00DF
, swizzle_y(r00C6
));
1032 ir_expression
*const r00E1
= logic_and(r00DE
, r00E0
);
1033 ir_if
*f00DC
= new(mem_ctx
) ir_if(operand(r00E1
).val
);
1034 exec_list
*const f00DC_parent_instructions
= body
.instructions
;
1036 /* THEN INSTRUCTIONS */
1037 body
.instructions
= &f00DC
->then_instructions
;
1039 ir_expression
*const r00E2
= lshift(swizzle_x(r00CA
), r00D7
);
1040 body
.emit(assign(r00C6
, sub(swizzle_y(r00C6
), r00E2
), 0x02));
1042 ir_expression
*const r00E3
= lshift(body
.constant(1u), r00D7
);
1043 body
.emit(assign(r00D1
, bit_or(swizzle_y(r00D1
), r00E3
), 0x02));
1046 body
.instructions
= f00DC_parent_instructions
;
1051 body
.emit(assign(r00D7
, add(r00D7
, body
.constant(int(-1))), 0x01));
1055 body
.instructions
= f00D9_parent_instructions
;
1059 ir_expression
*const r00E5
= lequal(swizzle_x(r00CA
), swizzle_y(r00C6
));
1060 ir_if
*f00E4
= new(mem_ctx
) ir_if(operand(r00E5
).val
);
1061 exec_list
*const f00E4_parent_instructions
= body
.instructions
;
1063 /* THEN INSTRUCTIONS */
1064 body
.instructions
= &f00E4
->then_instructions
;
1066 body
.emit(assign(r00C6
, sub(swizzle_y(r00C6
), swizzle_x(r00CA
)), 0x02));
1068 body
.emit(assign(r00D1
, bit_or(swizzle_y(r00D1
), body
.constant(1u)), 0x02));
1071 body
.instructions
= f00E4_parent_instructions
;
1077 body
.instructions
= f00D3_parent_instructions
;
1082 ir_variable
*const r00E6
= body
.make_temp(glsl_type::uint64_t_type
, "packUint2x32_retval");
1083 body
.emit(assign(r00E6
, expr(ir_unop_pack_uint_2x32
, r00CA
), 0x01));
1085 body
.emit(assign(r00CF
, expr(ir_unop_pack_uint_2x32
, r00C6
), 0x01));
1087 body
.emit(assign(r00CE
, body
.constant(int(31)), 0x01));
1090 ir_loop
*f00E7
= new(mem_ctx
) ir_loop();
1091 exec_list
*const f00E7_parent_instructions
= body
.instructions
;
1093 body
.instructions
= &f00E7
->body_instructions
;
1096 ir_expression
*const r00E9
= less(r00CE
, body
.constant(int(1)));
1097 ir_if
*f00E8
= new(mem_ctx
) ir_if(operand(r00E9
).val
);
1098 exec_list
*const f00E8_parent_instructions
= body
.instructions
;
1100 /* THEN INSTRUCTIONS */
1101 body
.instructions
= &f00E8
->then_instructions
;
1103 body
.emit(new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_break
));
1106 body
.instructions
= f00E8_parent_instructions
;
1112 ir_expression
*const r00EB
= sub(body
.constant(int(63)), r00CE
);
1113 ir_expression
*const r00EC
= lequal(r00D0
, r00EB
);
1114 ir_expression
*const r00ED
= lshift(r00E6
, r00CE
);
1115 ir_expression
*const r00EE
= lequal(r00ED
, r00CF
);
1116 ir_expression
*const r00EF
= logic_and(r00EC
, r00EE
);
1117 ir_if
*f00EA
= new(mem_ctx
) ir_if(operand(r00EF
).val
);
1118 exec_list
*const f00EA_parent_instructions
= body
.instructions
;
1120 /* THEN INSTRUCTIONS */
1121 body
.instructions
= &f00EA
->then_instructions
;
1123 ir_expression
*const r00F0
= lshift(r00E6
, r00CE
);
1124 body
.emit(assign(r00CF
, sub(r00CF
, r00F0
), 0x01));
1126 ir_expression
*const r00F1
= lshift(body
.constant(1u), r00CE
);
1127 body
.emit(assign(r00D1
, bit_or(swizzle_x(r00D1
), r00F1
), 0x01));
1130 body
.instructions
= f00EA_parent_instructions
;
1135 body
.emit(assign(r00CE
, add(r00CE
, body
.constant(int(-1))), 0x01));
1139 body
.instructions
= f00E7_parent_instructions
;
1143 ir_expression
*const r00F3
= lequal(r00E6
, r00CF
);
1144 ir_if
*f00F2
= new(mem_ctx
) ir_if(operand(r00F3
).val
);
1145 exec_list
*const f00F2_parent_instructions
= body
.instructions
;
1147 /* THEN INSTRUCTIONS */
1148 body
.instructions
= &f00F2
->then_instructions
;
1150 body
.emit(assign(r00CF
, sub(r00CF
, r00E6
), 0x01));
1152 body
.emit(assign(r00D1
, bit_or(swizzle_x(r00D1
), body
.constant(1u)), 0x01));
1155 body
.instructions
= f00F2_parent_instructions
;
1160 ir_variable
*const r00F4
= body
.make_temp(glsl_type::uvec4_type
, "vec_ctor");
1161 body
.emit(assign(r00F4
, r00D1
, 0x03));
1163 body
.emit(assign(r00F4
, expr(ir_unop_unpack_uint_2x32
, r00CF
), 0x0c));
1165 ir_variable
*const r00F5
= body
.make_temp(glsl_type::ivec2_type
, "conditional_tmp");
1167 ir_if
*f00F6
= new(mem_ctx
) ir_if(operand(r00C3
).val
);
1168 exec_list
*const f00F6_parent_instructions
= body
.instructions
;
1170 /* THEN INSTRUCTIONS */
1171 body
.instructions
= &f00F6
->then_instructions
;
1173 ir_swizzle
*const r00F7
= swizzle(r00F4
, MAKE_SWIZZLE4(SWIZZLE_Z
, SWIZZLE_W
, SWIZZLE_X
, SWIZZLE_X
), 2);
1174 ir_expression
*const r00F8
= expr(ir_unop_pack_uint_2x32
, r00F7
);
1175 ir_expression
*const r00F9
= expr(ir_unop_u642i64
, r00F8
);
1176 ir_expression
*const r00FA
= neg(r00F9
);
1177 body
.emit(assign(r00F5
, expr(ir_unop_unpack_int_2x32
, r00FA
), 0x03));
1180 /* ELSE INSTRUCTIONS */
1181 body
.instructions
= &f00F6
->else_instructions
;
1183 ir_swizzle
*const r00FB
= swizzle(r00F4
, MAKE_SWIZZLE4(SWIZZLE_Z
, SWIZZLE_W
, SWIZZLE_X
, SWIZZLE_X
), 2);
1184 body
.emit(assign(r00F5
, expr(ir_unop_u2i
, r00FB
), 0x03));
1187 body
.instructions
= f00F6_parent_instructions
;
1192 body
.emit(ret(r00F5
));
1194 sig
->replace_parameters(&sig_parameters
);