[Mesa-dev] [PATCH 36/50] glsl: Add a lowering pass for 64-bit float rcp()
Dave Airlie
airlied at gmail.com
Tue Mar 13 04:25:01 UTC 2018
From: Elie Tournier <tournier.elie at gmail.com>
[This uses fp32 division to work out rcp, the proper
code is included but needs further tuning to decide
if we need to use it - airlied]
Signed-off-by: Elie Tournier <elie.tournier at collabora.com>
---
src/compiler/glsl/builtin_float64.h | 2176 ++++++-----------------------------
src/compiler/glsl/float64.glsl | 8 +-
src/compiler/glsl/ir_optimization.h | 4 +-
src/compiler/glsl/lower_64bit.cpp | 7 +
4 files changed, 385 insertions(+), 1810 deletions(-)
diff --git a/src/compiler/glsl/builtin_float64.h b/src/compiler/glsl/builtin_float64.h
index e8ef0b0..5d1b94e 100644
--- a/src/compiler/glsl/builtin_float64.h
+++ b/src/compiler/glsl/builtin_float64.h
@@ -6707,217 +6707,217 @@ fround64(void *mem_ctx, builtin_available_predicate avail)
exec_list sig_parameters;
- ir_variable *const r0F1C = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
- sig_parameters.push_tail(r0F1C);
- ir_variable *const r0F1D = body.make_temp(glsl_type::bool_type, "execute_flag");
- body.emit(assign(r0F1D, body.constant(true), 0x01));
-
- ir_variable *const r0F1E = body.make_temp(glsl_type::uvec2_type, "return_value");
- ir_variable *const r0F1F = new(mem_ctx) ir_variable(glsl_type::uint_type, "aLo", ir_var_auto);
- body.emit(r0F1F);
- ir_variable *const r0F20 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHi", ir_var_auto);
- body.emit(r0F20);
- ir_variable *const r0F21 = body.make_temp(glsl_type::int_type, "assignment_tmp");
- ir_expression *const r0F22 = rshift(swizzle_y(r0F1C), body.constant(int(20)));
- ir_expression *const r0F23 = bit_and(r0F22, body.constant(2047u));
- ir_expression *const r0F24 = expr(ir_unop_u2i, r0F23);
- body.emit(assign(r0F21, add(r0F24, body.constant(int(-1023))), 0x01));
-
- body.emit(assign(r0F20, swizzle_y(r0F1C), 0x01));
-
- body.emit(assign(r0F1F, swizzle_x(r0F1C), 0x01));
+ ir_variable *const r0A40 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r0A40);
+ ir_variable *const r0A41 = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r0A41, body.constant(true), 0x01));
+
+ ir_variable *const r0A42 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r0A43 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aLo", ir_var_auto);
+ body.emit(r0A43);
+ ir_variable *const r0A44 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHi", ir_var_auto);
+ body.emit(r0A44);
+ ir_variable *const r0A45 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0A46 = rshift(swizzle_y(r0A40), body.constant(int(20)));
+ ir_expression *const r0A47 = bit_and(r0A46, body.constant(2047u));
+ ir_expression *const r0A48 = expr(ir_unop_u2i, r0A47);
+ body.emit(assign(r0A45, add(r0A48, body.constant(int(-1023))), 0x01));
+
+ body.emit(assign(r0A44, swizzle_y(r0A40), 0x01));
+
+ body.emit(assign(r0A43, swizzle_x(r0A40), 0x01));
/* IF CONDITION */
- ir_expression *const r0F26 = less(r0F21, body.constant(int(20)));
- ir_if *f0F25 = new(mem_ctx) ir_if(operand(r0F26).val);
- exec_list *const f0F25_parent_instructions = body.instructions;
+ ir_expression *const r0A4A = less(r0A45, body.constant(int(20)));
+ ir_if *f0A49 = new(mem_ctx) ir_if(operand(r0A4A).val);
+ exec_list *const f0A49_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F25->then_instructions;
+ body.instructions = &f0A49->then_instructions;
/* IF CONDITION */
- ir_expression *const r0F28 = less(r0F21, body.constant(int(0)));
- ir_if *f0F27 = new(mem_ctx) ir_if(operand(r0F28).val);
- exec_list *const f0F27_parent_instructions = body.instructions;
+ ir_expression *const r0A4C = less(r0A45, body.constant(int(0)));
+ ir_if *f0A4B = new(mem_ctx) ir_if(operand(r0A4C).val);
+ exec_list *const f0A4B_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F27->then_instructions;
+ body.instructions = &f0A4B->then_instructions;
- body.emit(assign(r0F20, bit_and(swizzle_y(r0F1C), body.constant(2147483648u)), 0x01));
+ body.emit(assign(r0A44, bit_and(swizzle_y(r0A40), body.constant(2147483648u)), 0x01));
/* IF CONDITION */
- ir_expression *const r0F2A = equal(r0F21, body.constant(int(-1)));
- ir_expression *const r0F2B = nequal(swizzle_x(r0F1C), body.constant(0u));
- ir_expression *const r0F2C = logic_and(r0F2A, r0F2B);
- ir_if *f0F29 = new(mem_ctx) ir_if(operand(r0F2C).val);
- exec_list *const f0F29_parent_instructions = body.instructions;
+ ir_expression *const r0A4E = equal(r0A45, body.constant(int(-1)));
+ ir_expression *const r0A4F = nequal(swizzle_x(r0A40), body.constant(0u));
+ ir_expression *const r0A50 = logic_and(r0A4E, r0A4F);
+ ir_if *f0A4D = new(mem_ctx) ir_if(operand(r0A50).val);
+ exec_list *const f0A4D_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F29->then_instructions;
+ body.instructions = &f0A4D->then_instructions;
- body.emit(assign(r0F20, bit_or(r0F20, body.constant(1072693248u)), 0x01));
+ body.emit(assign(r0A44, bit_or(r0A44, body.constant(1072693248u)), 0x01));
- body.instructions = f0F29_parent_instructions;
- body.emit(f0F29);
+ body.instructions = f0A4D_parent_instructions;
+ body.emit(f0A4D);
/* END IF */
- body.emit(assign(r0F1F, body.constant(0u), 0x01));
+ body.emit(assign(r0A43, body.constant(0u), 0x01));
/* ELSE INSTRUCTIONS */
- body.instructions = &f0F27->else_instructions;
+ body.instructions = &f0A4B->else_instructions;
- ir_variable *const r0F2D = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r0F2D, rshift(body.constant(1048575u), r0F21), 0x01));
+ ir_variable *const r0A51 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0A51, rshift(body.constant(1048575u), r0A45), 0x01));
/* IF CONDITION */
- ir_expression *const r0F2F = bit_and(r0F20, r0F2D);
- ir_expression *const r0F30 = equal(r0F2F, body.constant(0u));
- ir_expression *const r0F31 = equal(r0F1F, body.constant(0u));
- ir_expression *const r0F32 = logic_and(r0F30, r0F31);
- ir_if *f0F2E = new(mem_ctx) ir_if(operand(r0F32).val);
- exec_list *const f0F2E_parent_instructions = body.instructions;
+ ir_expression *const r0A53 = bit_and(r0A44, r0A51);
+ ir_expression *const r0A54 = equal(r0A53, body.constant(0u));
+ ir_expression *const r0A55 = equal(r0A43, body.constant(0u));
+ ir_expression *const r0A56 = logic_and(r0A54, r0A55);
+ ir_if *f0A52 = new(mem_ctx) ir_if(operand(r0A56).val);
+ exec_list *const f0A52_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F2E->then_instructions;
+ body.instructions = &f0A52->then_instructions;
- body.emit(assign(r0F1E, r0F1C, 0x03));
+ body.emit(assign(r0A42, r0A40, 0x03));
- body.emit(assign(r0F1D, body.constant(false), 0x01));
+ body.emit(assign(r0A41, body.constant(false), 0x01));
/* ELSE INSTRUCTIONS */
- body.instructions = &f0F2E->else_instructions;
+ body.instructions = &f0A52->else_instructions;
- ir_expression *const r0F33 = rshift(body.constant(524288u), r0F21);
- body.emit(assign(r0F20, add(r0F20, r0F33), 0x01));
+ ir_expression *const r0A57 = rshift(body.constant(524288u), r0A45);
+ body.emit(assign(r0A44, add(r0A44, r0A57), 0x01));
- ir_expression *const r0F34 = expr(ir_unop_bit_not, r0F2D);
- body.emit(assign(r0F20, bit_and(r0F20, r0F34), 0x01));
+ ir_expression *const r0A58 = expr(ir_unop_bit_not, r0A51);
+ body.emit(assign(r0A44, bit_and(r0A44, r0A58), 0x01));
- body.emit(assign(r0F1F, body.constant(0u), 0x01));
+ body.emit(assign(r0A43, body.constant(0u), 0x01));
- body.instructions = f0F2E_parent_instructions;
- body.emit(f0F2E);
+ body.instructions = f0A52_parent_instructions;
+ body.emit(f0A52);
/* END IF */
- body.instructions = f0F27_parent_instructions;
- body.emit(f0F27);
+ body.instructions = f0A4B_parent_instructions;
+ body.emit(f0A4B);
/* END IF */
/* ELSE INSTRUCTIONS */
- body.instructions = &f0F25->else_instructions;
+ body.instructions = &f0A49->else_instructions;
/* IF CONDITION */
- ir_expression *const r0F36 = greater(r0F21, body.constant(int(51)));
- ir_expression *const r0F37 = equal(r0F21, body.constant(int(1024)));
- ir_expression *const r0F38 = logic_or(r0F36, r0F37);
- ir_if *f0F35 = new(mem_ctx) ir_if(operand(r0F38).val);
- exec_list *const f0F35_parent_instructions = body.instructions;
+ ir_expression *const r0A5A = less(body.constant(int(51)), r0A45);
+ ir_expression *const r0A5B = equal(r0A45, body.constant(int(1024)));
+ ir_expression *const r0A5C = logic_or(r0A5A, r0A5B);
+ ir_if *f0A59 = new(mem_ctx) ir_if(operand(r0A5C).val);
+ exec_list *const f0A59_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F35->then_instructions;
+ body.instructions = &f0A59->then_instructions;
- body.emit(assign(r0F1E, r0F1C, 0x03));
+ body.emit(assign(r0A42, r0A40, 0x03));
- body.emit(assign(r0F1D, body.constant(false), 0x01));
+ body.emit(assign(r0A41, body.constant(false), 0x01));
/* ELSE INSTRUCTIONS */
- body.instructions = &f0F35->else_instructions;
+ body.instructions = &f0A59->else_instructions;
- ir_variable *const r0F39 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- ir_expression *const r0F3A = add(r0F21, body.constant(int(-20)));
- body.emit(assign(r0F39, rshift(body.constant(4294967295u), r0F3A), 0x01));
+ ir_variable *const r0A5D = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ ir_expression *const r0A5E = add(r0A45, body.constant(int(-20)));
+ body.emit(assign(r0A5D, rshift(body.constant(4294967295u), r0A5E), 0x01));
/* IF CONDITION */
- ir_expression *const r0F3C = bit_and(r0F1F, r0F39);
- ir_expression *const r0F3D = equal(r0F3C, body.constant(0u));
- ir_if *f0F3B = new(mem_ctx) ir_if(operand(r0F3D).val);
- exec_list *const f0F3B_parent_instructions = body.instructions;
+ ir_expression *const r0A60 = bit_and(r0A43, r0A5D);
+ ir_expression *const r0A61 = equal(r0A60, body.constant(0u));
+ ir_if *f0A5F = new(mem_ctx) ir_if(operand(r0A61).val);
+ exec_list *const f0A5F_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F3B->then_instructions;
+ body.instructions = &f0A5F->then_instructions;
- body.emit(assign(r0F1E, r0F1C, 0x03));
+ body.emit(assign(r0A42, r0A40, 0x03));
- body.emit(assign(r0F1D, body.constant(false), 0x01));
+ body.emit(assign(r0A41, body.constant(false), 0x01));
/* ELSE INSTRUCTIONS */
- body.instructions = &f0F3B->else_instructions;
+ body.instructions = &f0A5F->else_instructions;
- ir_variable *const r0F3E = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- ir_expression *const r0F3F = sub(body.constant(int(51)), r0F21);
- ir_expression *const r0F40 = lshift(body.constant(1u), r0F3F);
- body.emit(assign(r0F3E, add(r0F1F, r0F40), 0x01));
+ ir_variable *const r0A62 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ ir_expression *const r0A63 = sub(body.constant(int(51)), r0A45);
+ ir_expression *const r0A64 = lshift(body.constant(1u), r0A63);
+ body.emit(assign(r0A62, add(r0A43, r0A64), 0x01));
/* IF CONDITION */
- ir_expression *const r0F42 = less(r0F3E, r0F1F);
- ir_if *f0F41 = new(mem_ctx) ir_if(operand(r0F42).val);
- exec_list *const f0F41_parent_instructions = body.instructions;
+ ir_expression *const r0A66 = less(r0A62, r0A43);
+ ir_if *f0A65 = new(mem_ctx) ir_if(operand(r0A66).val);
+ exec_list *const f0A65_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F41->then_instructions;
+ body.instructions = &f0A65->then_instructions;
- body.emit(assign(r0F20, add(r0F20, body.constant(1u)), 0x01));
+ body.emit(assign(r0A44, add(r0A44, body.constant(1u)), 0x01));
- body.instructions = f0F41_parent_instructions;
- body.emit(f0F41);
+ body.instructions = f0A65_parent_instructions;
+ body.emit(f0A65);
/* END IF */
- ir_expression *const r0F43 = expr(ir_unop_bit_not, r0F39);
- body.emit(assign(r0F1F, bit_and(r0F3E, r0F43), 0x01));
+ ir_expression *const r0A67 = expr(ir_unop_bit_not, r0A5D);
+ body.emit(assign(r0A43, bit_and(r0A62, r0A67), 0x01));
- body.instructions = f0F3B_parent_instructions;
- body.emit(f0F3B);
+ body.instructions = f0A5F_parent_instructions;
+ body.emit(f0A5F);
/* END IF */
- body.instructions = f0F35_parent_instructions;
- body.emit(f0F35);
+ body.instructions = f0A59_parent_instructions;
+ body.emit(f0A59);
/* END IF */
- body.instructions = f0F25_parent_instructions;
- body.emit(f0F25);
+ body.instructions = f0A49_parent_instructions;
+ body.emit(f0A49);
/* END IF */
/* IF CONDITION */
- ir_if *f0F44 = new(mem_ctx) ir_if(operand(r0F1D).val);
- exec_list *const f0F44_parent_instructions = body.instructions;
+ ir_if *f0A68 = new(mem_ctx) ir_if(operand(r0A41).val);
+ exec_list *const f0A68_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F44->then_instructions;
+ body.instructions = &f0A68->then_instructions;
- body.emit(assign(r0F1C, r0F1F, 0x01));
+ body.emit(assign(r0A40, r0A43, 0x01));
- body.emit(assign(r0F1C, r0F20, 0x02));
+ body.emit(assign(r0A40, r0A44, 0x02));
- body.emit(assign(r0F1E, r0F1C, 0x03));
+ body.emit(assign(r0A42, r0A40, 0x03));
- body.emit(assign(r0F1D, body.constant(false), 0x01));
+ body.emit(assign(r0A41, body.constant(false), 0x01));
- body.instructions = f0F44_parent_instructions;
- body.emit(f0F44);
+ body.instructions = f0A68_parent_instructions;
+ body.emit(f0A68);
/* END IF */
- body.emit(ret(r0F1E));
+ body.emit(ret(r0A42));
sig->replace_parameters(&sig_parameters);
return sig;
@@ -6932,1821 +6932,385 @@ frcp64(void *mem_ctx, builtin_available_predicate avail)
exec_list sig_parameters;
- ir_variable *const r0F45 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
- sig_parameters.push_tail(r0F45);
- ir_variable *const r0F46 = body.make_temp(glsl_type::uint_type, "z1Ptr");
- body.emit(assign(r0F46, sub(body.constant(2406117202u), swizzle_x(r0F45)), 0x01));
+ ir_variable *const r0A69 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r0A69);
+ ir_variable *const r0A6A = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r0A6A, r0A69, 0x03));
- ir_expression *const r0F47 = sub(body.constant(3217938081u), swizzle_y(r0F45));
- ir_expression *const r0F48 = less(body.constant(2406117202u), swizzle_x(r0F45));
- ir_expression *const r0F49 = expr(ir_unop_b2i, r0F48);
- ir_expression *const r0F4A = expr(ir_unop_i2u, r0F49);
- body.emit(assign(r0F45, sub(r0F47, r0F4A), 0x02));
+ ir_variable *const r0A6B = body.make_temp(glsl_type::float_type, "return_value");
+ ir_variable *const r0A6C = body.make_temp(glsl_type::uint_type, "extractFloat64FracHi_retval");
+ body.emit(assign(r0A6C, bit_and(swizzle_y(r0A69), body.constant(1048575u)), 0x01));
- body.emit(assign(r0F45, r0F46, 0x01));
+ ir_variable *const r0A6D = body.make_temp(glsl_type::int_type, "extractFloat64Exp_retval");
+ ir_expression *const r0A6E = rshift(swizzle_y(r0A69), body.constant(int(20)));
+ ir_expression *const r0A6F = bit_and(r0A6E, body.constant(2047u));
+ body.emit(assign(r0A6D, expr(ir_unop_u2i, r0A6F), 0x01));
- ir_variable *const r0F4B = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
- body.emit(r0F4B);
- ir_variable *const r0F4C = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
- body.emit(r0F4C);
- ir_expression *const r0F4D = lshift(swizzle_y(r0F45), body.constant(int(31)));
- ir_expression *const r0F4E = rshift(r0F46, body.constant(int(1)));
- body.emit(assign(r0F4B, bit_or(r0F4D, r0F4E), 0x01));
+ ir_variable *const r0A70 = body.make_temp(glsl_type::uint_type, "extractFloat64Sign_retval");
+ body.emit(assign(r0A70, rshift(swizzle_y(r0A69), body.constant(int(31))), 0x01));
- body.emit(assign(r0F4C, rshift(swizzle_y(r0F45), body.constant(int(1))), 0x01));
-
- body.emit(assign(r0F45, r0F4C, 0x02));
-
- body.emit(assign(r0F45, r0F4B, 0x01));
-
- ir_variable *const r0F4F = body.make_temp(glsl_type::bool_type, "execute_flag");
- body.emit(assign(r0F4F, body.constant(true), 0x01));
-
- ir_variable *const r0F50 = body.make_temp(glsl_type::uvec2_type, "return_value");
- ir_variable *const r0F51 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zSign", ir_var_auto);
- body.emit(r0F51);
- ir_variable *const r0F52 = new(mem_ctx) ir_variable(glsl_type::int_type, "bExp", ir_var_auto);
- body.emit(r0F52);
- ir_variable *const r0F53 = new(mem_ctx) ir_variable(glsl_type::int_type, "aExp", ir_var_auto);
- body.emit(r0F53);
- ir_variable *const r0F54 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bFracHi", ir_var_auto);
- body.emit(r0F54);
- ir_variable *const r0F55 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bFracLo", ir_var_auto);
- body.emit(r0F55);
- ir_variable *const r0F56 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aFracHi", ir_var_auto);
- body.emit(r0F56);
- ir_variable *const r0F57 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aFracLo", ir_var_auto);
- body.emit(r0F57);
- ir_variable *const r0F58 = new(mem_ctx) ir_variable(glsl_type::int_type, "zExp", ir_var_auto);
- body.emit(r0F58);
- ir_variable *const r0F59 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_auto);
- body.emit(r0F59);
- ir_variable *const r0F5A = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1", ir_var_auto);
- body.emit(r0F5A);
- ir_variable *const r0F5B = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0", ir_var_auto);
- body.emit(r0F5B);
- body.emit(assign(r0F5B, body.constant(0u), 0x01));
-
- body.emit(assign(r0F5A, body.constant(0u), 0x01));
-
- body.emit(assign(r0F59, body.constant(0u), 0x01));
-
- ir_variable *const r0F5C = body.make_temp(glsl_type::uint_type, "extractFloat64FracLo_retval");
- body.emit(assign(r0F5C, swizzle_x(r0F45), 0x01));
-
- body.emit(assign(r0F57, r0F5C, 0x01));
-
- ir_variable *const r0F5D = body.make_temp(glsl_type::uint_type, "extractFloat64FracHi_retval");
- body.emit(assign(r0F5D, bit_and(r0F4C, body.constant(1048575u)), 0x01));
-
- body.emit(assign(r0F56, r0F5D, 0x01));
-
- ir_variable *const r0F5E = body.make_temp(glsl_type::uint_type, "extractFloat64FracLo_retval");
- body.emit(assign(r0F5E, swizzle_x(r0F45), 0x01));
-
- body.emit(assign(r0F55, r0F5E, 0x01));
+ /* IF CONDITION */
+ ir_expression *const r0A72 = equal(r0A6D, body.constant(int(2047)));
+ ir_if *f0A71 = new(mem_ctx) ir_if(operand(r0A72).val);
+ exec_list *const f0A71_parent_instructions = body.instructions;
- ir_variable *const r0F5F = body.make_temp(glsl_type::uint_type, "extractFloat64FracHi_retval");
- body.emit(assign(r0F5F, bit_and(r0F4C, body.constant(1048575u)), 0x01));
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0A71->then_instructions;
- body.emit(assign(r0F54, r0F5F, 0x01));
+ ir_variable *const r0A73 = new(mem_ctx) ir_variable(glsl_type::float_type, "rval", ir_var_auto);
+ body.emit(r0A73);
+ ir_expression *const r0A74 = lshift(swizzle_y(r0A69), body.constant(int(12)));
+ ir_expression *const r0A75 = rshift(swizzle_x(r0A69), body.constant(int(20)));
+ body.emit(assign(r0A6A, bit_or(r0A74, r0A75), 0x02));
- ir_variable *const r0F60 = body.make_temp(glsl_type::int_type, "extractFloat64Exp_retval");
- ir_expression *const r0F61 = rshift(r0F4C, body.constant(int(20)));
- ir_expression *const r0F62 = bit_and(r0F61, body.constant(2047u));
- body.emit(assign(r0F60, expr(ir_unop_u2i, r0F62), 0x01));
+ body.emit(assign(r0A6A, lshift(swizzle_x(r0A69), body.constant(int(12))), 0x01));
- body.emit(assign(r0F53, r0F60, 0x01));
+ ir_expression *const r0A76 = lshift(r0A70, body.constant(int(31)));
+ ir_expression *const r0A77 = bit_or(r0A76, body.constant(2143289344u));
+ ir_expression *const r0A78 = rshift(swizzle_y(r0A6A), body.constant(int(9)));
+ ir_expression *const r0A79 = bit_or(r0A77, r0A78);
+ body.emit(assign(r0A73, expr(ir_unop_bitcast_u2f, r0A79), 0x01));
- ir_variable *const r0F63 = body.make_temp(glsl_type::int_type, "extractFloat64Exp_retval");
- ir_expression *const r0F64 = rshift(r0F4C, body.constant(int(20)));
- ir_expression *const r0F65 = bit_and(r0F64, body.constant(2047u));
- body.emit(assign(r0F63, expr(ir_unop_u2i, r0F65), 0x01));
+ ir_variable *const r0A7A = body.make_temp(glsl_type::float_type, "mix_retval");
+ ir_expression *const r0A7B = bit_or(r0A6C, swizzle_x(r0A69));
+ ir_expression *const r0A7C = nequal(r0A7B, body.constant(0u));
+ ir_expression *const r0A7D = lshift(r0A70, body.constant(int(31)));
+ ir_expression *const r0A7E = add(r0A7D, body.constant(2139095040u));
+ ir_expression *const r0A7F = expr(ir_unop_bitcast_u2f, r0A7E);
+ body.emit(assign(r0A7A, expr(ir_triop_csel, r0A7C, r0A73, r0A7F), 0x01));
- body.emit(assign(r0F52, r0F63, 0x01));
+ body.emit(assign(r0A73, r0A7A, 0x01));
- ir_expression *const r0F66 = rshift(r0F4C, body.constant(int(31)));
- ir_expression *const r0F67 = rshift(r0F4C, body.constant(int(31)));
- body.emit(assign(r0F51, bit_xor(r0F66, r0F67), 0x01));
+ body.emit(assign(r0A6B, r0A7A, 0x01));
- /* IF CONDITION */
- ir_expression *const r0F69 = equal(r0F60, body.constant(int(2047)));
- ir_if *f0F68 = new(mem_ctx) ir_if(operand(r0F69).val);
- exec_list *const f0F68_parent_instructions = body.instructions;
- /* THEN INSTRUCTIONS */
- body.instructions = &f0F68->then_instructions;
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0A71->else_instructions;
+
+ ir_variable *const r0A80 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0A81 = lshift(r0A6C, body.constant(int(10)));
+ ir_expression *const r0A82 = rshift(swizzle_x(r0A69), body.constant(int(22)));
+ ir_expression *const r0A83 = bit_or(r0A81, r0A82);
+ ir_expression *const r0A84 = lshift(swizzle_x(r0A69), body.constant(int(10)));
+ ir_expression *const r0A85 = nequal(r0A84, body.constant(0u));
+ ir_expression *const r0A86 = expr(ir_unop_b2i, r0A85);
+ ir_expression *const r0A87 = expr(ir_unop_i2u, r0A86);
+ body.emit(assign(r0A80, bit_or(r0A83, r0A87), 0x01));
+
+ ir_variable *const r0A88 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0A89 = nequal(r0A6D, body.constant(int(0)));
+ ir_expression *const r0A8A = bit_or(r0A80, body.constant(1073741824u));
+ body.emit(assign(r0A88, expr(ir_triop_csel, r0A89, r0A8A, r0A80), 0x01));
+
+ ir_variable *const r0A8B = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r0A8B, add(r0A6D, body.constant(int(-897))), 0x01));
+
+ ir_variable *const r0A8C = body.make_temp(glsl_type::uint_type, "zFrac");
+ body.emit(assign(r0A8C, r0A88, 0x01));
+
+ ir_variable *const r0A8D = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r0A8D, body.constant(true), 0x01));
+
+ ir_variable *const r0A8E = body.make_temp(glsl_type::float_type, "return_value");
+ ir_variable *const r0A8F = new(mem_ctx) ir_variable(glsl_type::int_type, "roundBits", ir_var_auto);
+ body.emit(r0A8F);
+ ir_expression *const r0A90 = bit_and(r0A88, body.constant(127u));
+ body.emit(assign(r0A8F, expr(ir_unop_u2i, r0A90), 0x01));
/* IF CONDITION */
- ir_expression *const r0F6B = bit_or(r0F5D, r0F4B);
- ir_expression *const r0F6C = nequal(r0F6B, body.constant(0u));
- ir_expression *const r0F6D = equal(r0F63, body.constant(int(2047)));
- ir_expression *const r0F6E = bit_or(r0F5F, r0F4B);
- ir_expression *const r0F6F = nequal(r0F6E, body.constant(0u));
- ir_expression *const r0F70 = logic_and(r0F6D, r0F6F);
- ir_expression *const r0F71 = logic_or(r0F6C, r0F70);
- ir_if *f0F6A = new(mem_ctx) ir_if(operand(r0F71).val);
- exec_list *const f0F6A_parent_instructions = body.instructions;
+ ir_expression *const r0A92 = expr(ir_unop_i2u, r0A8B);
+ ir_expression *const r0A93 = gequal(r0A92, body.constant(253u));
+ ir_if *f0A91 = new(mem_ctx) ir_if(operand(r0A93).val);
+ exec_list *const f0A91_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F6A->then_instructions;
-
- ir_variable *const r0F72 = body.make_temp(glsl_type::uvec2_type, "a");
- body.emit(assign(r0F72, swizzle_x(r0F45), 0x01));
-
- ir_variable *const r0F73 = body.make_temp(glsl_type::uvec2_type, "b");
- body.emit(assign(r0F73, swizzle_x(r0F45), 0x01));
-
- ir_variable *const r0F74 = body.make_temp(glsl_type::uvec2_type, "return_value");
- ir_variable *const r0F75 = body.make_temp(glsl_type::bool_type, "is_nan_retval");
- ir_expression *const r0F76 = lshift(r0F4C, body.constant(int(1)));
- ir_expression *const r0F77 = lequal(body.constant(4292870144u), r0F76);
- ir_expression *const r0F78 = nequal(r0F4B, body.constant(0u));
- ir_expression *const r0F79 = bit_and(r0F4C, body.constant(1048575u));
- ir_expression *const r0F7A = nequal(r0F79, body.constant(0u));
- ir_expression *const r0F7B = logic_or(r0F78, r0F7A);
- body.emit(assign(r0F75, logic_and(r0F77, r0F7B), 0x01));
-
- body.emit(assign(r0F72, bit_or(r0F4C, body.constant(524288u)), 0x02));
-
- body.emit(assign(r0F73, bit_or(r0F4C, body.constant(524288u)), 0x02));
+ body.instructions = &f0A91->then_instructions;
/* IF CONDITION */
- ir_expression *const r0F7D = lshift(r0F4C, body.constant(int(1)));
- ir_expression *const r0F7E = lequal(body.constant(4292870144u), r0F7D);
- ir_expression *const r0F7F = nequal(r0F4B, body.constant(0u));
- ir_expression *const r0F80 = bit_and(r0F4C, body.constant(1048575u));
- ir_expression *const r0F81 = nequal(r0F80, body.constant(0u));
- ir_expression *const r0F82 = logic_or(r0F7F, r0F81);
- ir_expression *const r0F83 = logic_and(r0F7E, r0F82);
- ir_if *f0F7C = new(mem_ctx) ir_if(operand(r0F83).val);
- exec_list *const f0F7C_parent_instructions = body.instructions;
+ ir_expression *const r0A95 = less(body.constant(int(253)), r0A8B);
+ ir_expression *const r0A96 = equal(r0A8B, body.constant(int(253)));
+ ir_expression *const r0A97 = expr(ir_unop_u2i, r0A88);
+ ir_expression *const r0A98 = less(r0A97, body.constant(int(-64)));
+ ir_expression *const r0A99 = logic_and(r0A96, r0A98);
+ ir_expression *const r0A9A = logic_or(r0A95, r0A99);
+ ir_if *f0A94 = new(mem_ctx) ir_if(operand(r0A9A).val);
+ exec_list *const f0A94_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F7C->then_instructions;
-
- ir_variable *const r0F84 = body.make_temp(glsl_type::uvec2_type, "conditional_tmp");
- /* IF CONDITION */
- ir_if *f0F85 = new(mem_ctx) ir_if(operand(r0F75).val);
- exec_list *const f0F85_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0F85->then_instructions;
-
- body.emit(assign(r0F84, r0F73, 0x03));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0F85->else_instructions;
-
- body.emit(assign(r0F84, r0F72, 0x03));
-
+ body.instructions = &f0A94->then_instructions;
- body.instructions = f0F85_parent_instructions;
- body.emit(f0F85);
+ ir_expression *const r0A9B = lshift(r0A70, body.constant(int(31)));
+ ir_expression *const r0A9C = add(r0A9B, body.constant(2139095040u));
+ body.emit(assign(r0A8E, expr(ir_unop_bitcast_u2f, r0A9C), 0x01));
- /* END IF */
-
- body.emit(assign(r0F74, r0F84, 0x03));
+ body.emit(assign(r0A8D, body.constant(false), 0x01));
/* ELSE INSTRUCTIONS */
- body.instructions = &f0F7C->else_instructions;
-
- body.emit(assign(r0F74, r0F73, 0x03));
-
-
- body.instructions = f0F7C_parent_instructions;
- body.emit(f0F7C);
-
- /* END IF */
-
- body.emit(assign(r0F50, r0F74, 0x03));
-
- body.emit(assign(r0F4F, body.constant(false), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0F6A->else_instructions;
-
- /* IF CONDITION */
- ir_expression *const r0F87 = expr(ir_unop_i2u, r0F63);
- ir_expression *const r0F88 = bit_or(r0F87, r0F5F);
- ir_expression *const r0F89 = bit_or(r0F88, r0F4B);
- ir_expression *const r0F8A = equal(r0F89, body.constant(0u));
- ir_if *f0F86 = new(mem_ctx) ir_if(operand(r0F8A).val);
- exec_list *const f0F86_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0F86->then_instructions;
+ body.instructions = &f0A94->else_instructions;
- ir_constant_data r0F8B_data;
- memset(&r0F8B_data, 0, sizeof(ir_constant_data));
- r0F8B_data.u[0] = 4294967295;
- r0F8B_data.u[1] = 4294967295;
- ir_constant *const r0F8B = new(mem_ctx) ir_constant(glsl_type::uvec2_type, &r0F8B_data);
- body.emit(assign(r0F50, r0F8B, 0x03));
+ ir_variable *const r0A9D = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ body.emit(assign(r0A9D, neg(r0A8B), 0x01));
- body.emit(assign(r0F4F, body.constant(false), 0x01));
+ ir_variable *const r0A9E = body.make_temp(glsl_type::bool_type, "assignment_tmp");
+ body.emit(assign(r0A9E, less(r0A8B, body.constant(int(0))), 0x01));
+ ir_variable *const r0A9F = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0AA0 = neg(r0A8B);
+ ir_expression *const r0AA1 = less(r0AA0, body.constant(int(32)));
+ ir_expression *const r0AA2 = rshift(r0A88, r0A9D);
+ ir_expression *const r0AA3 = neg(r0A9D);
+ ir_expression *const r0AA4 = bit_and(r0AA3, body.constant(int(31)));
+ ir_expression *const r0AA5 = lshift(r0A88, r0AA4);
+ ir_expression *const r0AA6 = nequal(r0AA5, body.constant(0u));
+ ir_expression *const r0AA7 = expr(ir_unop_b2i, r0AA6);
+ ir_expression *const r0AA8 = expr(ir_unop_i2u, r0AA7);
+ ir_expression *const r0AA9 = bit_or(r0AA2, r0AA8);
+ ir_expression *const r0AAA = nequal(r0A88, body.constant(0u));
+ ir_expression *const r0AAB = expr(ir_unop_b2i, r0AAA);
+ ir_expression *const r0AAC = expr(ir_unop_i2u, r0AAB);
+ ir_expression *const r0AAD = expr(ir_triop_csel, r0AA1, r0AA9, r0AAC);
+ body.emit(assign(r0A9F, expr(ir_triop_csel, r0A9E, r0AAD, r0A88), 0x01));
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0F86->else_instructions;
-
- ir_variable *const r0F8C = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
- body.emit(r0F8C);
- ir_expression *const r0F8D = lshift(r0F51, body.constant(int(31)));
- body.emit(assign(r0F8C, add(r0F8D, body.constant(2146435072u)), 0x02));
+ body.emit(assign(r0A8C, r0A9F, 0x01));
- body.emit(assign(r0F8C, body.constant(0u), 0x01));
+ ir_expression *const r0AAE = expr(ir_unop_u2i, r0A9F);
+ ir_expression *const r0AAF = bit_and(r0AAE, body.constant(int(127)));
+ body.emit(assign(r0A8F, expr(ir_triop_csel, r0A9E, r0AAF, r0A8F), 0x01));
- body.emit(assign(r0F50, r0F8C, 0x03));
+ body.emit(assign(r0A8B, expr(ir_triop_csel, r0A9E, body.constant(int(0)), r0A8B), 0x01));
- body.emit(assign(r0F4F, body.constant(false), 0x01));
-
- body.instructions = f0F86_parent_instructions;
- body.emit(f0F86);
+ body.instructions = f0A94_parent_instructions;
+ body.emit(f0A94);
/* END IF */
- body.instructions = f0F6A_parent_instructions;
- body.emit(f0F6A);
+ body.instructions = f0A91_parent_instructions;
+ body.emit(f0A91);
/* END IF */
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0F68->else_instructions;
-
/* IF CONDITION */
- ir_expression *const r0F8F = equal(r0F63, body.constant(int(2047)));
- ir_if *f0F8E = new(mem_ctx) ir_if(operand(r0F8F).val);
- exec_list *const f0F8E_parent_instructions = body.instructions;
+ ir_if *f0AB0 = new(mem_ctx) ir_if(operand(r0A8D).val);
+ exec_list *const f0AB0_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0F8E->then_instructions;
-
- /* IF CONDITION */
- ir_expression *const r0F91 = bit_or(r0F5F, r0F4B);
- ir_expression *const r0F92 = nequal(r0F91, body.constant(0u));
- ir_if *f0F90 = new(mem_ctx) ir_if(operand(r0F92).val);
- exec_list *const f0F90_parent_instructions = body.instructions;
+ body.instructions = &f0AB0->then_instructions;
- /* THEN INSTRUCTIONS */
- body.instructions = &f0F90->then_instructions;
-
- ir_variable *const r0F93 = body.make_temp(glsl_type::uvec2_type, "a");
- body.emit(assign(r0F93, swizzle_x(r0F45), 0x01));
-
- ir_variable *const r0F94 = body.make_temp(glsl_type::uvec2_type, "b");
- body.emit(assign(r0F94, swizzle_x(r0F45), 0x01));
-
- ir_variable *const r0F95 = body.make_temp(glsl_type::uvec2_type, "return_value");
- ir_variable *const r0F96 = body.make_temp(glsl_type::bool_type, "is_nan_retval");
- ir_expression *const r0F97 = lshift(r0F4C, body.constant(int(1)));
- ir_expression *const r0F98 = lequal(body.constant(4292870144u), r0F97);
- ir_expression *const r0F99 = nequal(r0F4B, body.constant(0u));
- ir_expression *const r0F9A = bit_and(r0F4C, body.constant(1048575u));
- ir_expression *const r0F9B = nequal(r0F9A, body.constant(0u));
- ir_expression *const r0F9C = logic_or(r0F99, r0F9B);
- body.emit(assign(r0F96, logic_and(r0F98, r0F9C), 0x01));
-
- body.emit(assign(r0F93, bit_or(r0F4C, body.constant(524288u)), 0x02));
-
- body.emit(assign(r0F94, bit_or(r0F4C, body.constant(524288u)), 0x02));
-
- /* IF CONDITION */
- ir_expression *const r0F9E = lshift(r0F4C, body.constant(int(1)));
- ir_expression *const r0F9F = lequal(body.constant(4292870144u), r0F9E);
- ir_expression *const r0FA0 = nequal(r0F4B, body.constant(0u));
- ir_expression *const r0FA1 = bit_and(r0F4C, body.constant(1048575u));
- ir_expression *const r0FA2 = nequal(r0FA1, body.constant(0u));
- ir_expression *const r0FA3 = logic_or(r0FA0, r0FA2);
- ir_expression *const r0FA4 = logic_and(r0F9F, r0FA3);
- ir_if *f0F9D = new(mem_ctx) ir_if(operand(r0FA4).val);
- exec_list *const f0F9D_parent_instructions = body.instructions;
+ ir_expression *const r0AB1 = add(r0A8C, body.constant(64u));
+ body.emit(assign(r0A8C, rshift(r0AB1, body.constant(int(7))), 0x01));
- /* THEN INSTRUCTIONS */
- body.instructions = &f0F9D->then_instructions;
+ ir_expression *const r0AB2 = bit_xor(r0A8F, body.constant(int(64)));
+ ir_expression *const r0AB3 = equal(r0AB2, body.constant(int(0)));
+ ir_expression *const r0AB4 = expr(ir_unop_b2i, r0AB3);
+ ir_expression *const r0AB5 = expr(ir_unop_i2u, r0AB4);
+ ir_expression *const r0AB6 = expr(ir_unop_bit_not, r0AB5);
+ body.emit(assign(r0A8C, bit_and(r0A8C, r0AB6), 0x01));
- ir_variable *const r0FA5 = body.make_temp(glsl_type::uvec2_type, "conditional_tmp");
- /* IF CONDITION */
- ir_if *f0FA6 = new(mem_ctx) ir_if(operand(r0F96).val);
- exec_list *const f0FA6_parent_instructions = body.instructions;
+ ir_expression *const r0AB7 = lshift(r0A70, body.constant(int(31)));
+ ir_expression *const r0AB8 = equal(r0A8C, body.constant(0u));
+ ir_expression *const r0AB9 = expr(ir_triop_csel, r0AB8, body.constant(int(0)), r0A8B);
+ ir_expression *const r0ABA = expr(ir_unop_i2u, r0AB9);
+ ir_expression *const r0ABB = lshift(r0ABA, body.constant(int(23)));
+ ir_expression *const r0ABC = add(r0AB7, r0ABB);
+ ir_expression *const r0ABD = add(r0ABC, r0A8C);
+ body.emit(assign(r0A8E, expr(ir_unop_bitcast_u2f, r0ABD), 0x01));
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FA6->then_instructions;
+ body.emit(assign(r0A8D, body.constant(false), 0x01));
- body.emit(assign(r0FA5, r0F94, 0x03));
+ body.instructions = f0AB0_parent_instructions;
+ body.emit(f0AB0);
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FA6->else_instructions;
+ /* END IF */
- body.emit(assign(r0FA5, r0F93, 0x03));
+ body.emit(assign(r0A6B, r0A8E, 0x01));
- body.instructions = f0FA6_parent_instructions;
- body.emit(f0FA6);
+ body.instructions = f0A71_parent_instructions;
+ body.emit(f0A71);
- /* END IF */
+ /* END IF */
- body.emit(assign(r0F95, r0FA5, 0x03));
+ ir_variable *const r0ABE = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r0ABE, body.constant(true), 0x01));
+ ir_variable *const r0ABF = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r0AC0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aSign", ir_var_auto);
+ body.emit(r0AC0);
+ ir_variable *const r0AC1 = new(mem_ctx) ir_variable(glsl_type::int_type, "aExp", ir_var_auto);
+ body.emit(r0AC1);
+ ir_variable *const r0AC2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aFrac", ir_var_auto);
+ body.emit(r0AC2);
+ ir_variable *const r0AC3 = body.make_temp(glsl_type::uint_type, "floatBitsToUint_retval");
+ ir_expression *const r0AC4 = expr(ir_unop_rcp, r0A6B);
+ body.emit(assign(r0AC3, expr(ir_unop_bitcast_f2u, r0AC4), 0x01));
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0F9D->else_instructions;
+ ir_variable *const r0AC5 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0AC5, bit_and(r0AC3, body.constant(8388607u)), 0x01));
- body.emit(assign(r0F95, r0F94, 0x03));
+ body.emit(assign(r0AC2, r0AC5, 0x01));
+ ir_variable *const r0AC6 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0AC7 = rshift(r0AC3, body.constant(int(23)));
+ ir_expression *const r0AC8 = bit_and(r0AC7, body.constant(255u));
+ body.emit(assign(r0AC6, expr(ir_unop_u2i, r0AC8), 0x01));
- body.instructions = f0F9D_parent_instructions;
- body.emit(f0F9D);
+ body.emit(assign(r0AC1, r0AC6, 0x01));
- /* END IF */
+ body.emit(assign(r0AC0, rshift(r0AC3, body.constant(int(31))), 0x01));
- body.emit(assign(r0F50, r0F95, 0x03));
+ /* IF CONDITION */
+ ir_expression *const r0ACA = equal(r0AC6, body.constant(int(255)));
+ ir_if *f0AC9 = new(mem_ctx) ir_if(operand(r0ACA).val);
+ exec_list *const f0AC9_parent_instructions = body.instructions;
- body.emit(assign(r0F4F, body.constant(false), 0x01));
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0AC9->then_instructions;
+ /* IF CONDITION */
+ ir_expression *const r0ACC = nequal(r0AC5, body.constant(0u));
+ ir_if *f0ACB = new(mem_ctx) ir_if(operand(r0ACC).val);
+ exec_list *const f0ACB_parent_instructions = body.instructions;
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0F90->else_instructions;
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0ACB->then_instructions;
- /* IF CONDITION */
- ir_expression *const r0FA8 = expr(ir_unop_i2u, r0F60);
- ir_expression *const r0FA9 = bit_or(r0FA8, r0F5D);
- ir_expression *const r0FAA = bit_or(r0FA9, r0F4B);
- ir_expression *const r0FAB = equal(r0FAA, body.constant(0u));
- ir_if *f0FA7 = new(mem_ctx) ir_if(operand(r0FAB).val);
- exec_list *const f0FA7_parent_instructions = body.instructions;
+ ir_variable *const r0ACD = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0ACD, lshift(r0AC3, body.constant(int(9))), 0x01));
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FA7->then_instructions;
+ ir_variable *const r0ACE = body.make_temp(glsl_type::uvec2_type, "vec_ctor");
+ ir_expression *const r0ACF = lshift(r0ACD, body.constant(int(20)));
+ body.emit(assign(r0ACE, bit_or(r0ACF, body.constant(0u)), 0x01));
- ir_constant_data r0FAC_data;
- memset(&r0FAC_data, 0, sizeof(ir_constant_data));
- r0FAC_data.u[0] = 4294967295;
- r0FAC_data.u[1] = 4294967295;
- ir_constant *const r0FAC = new(mem_ctx) ir_constant(glsl_type::uvec2_type, &r0FAC_data);
- body.emit(assign(r0F50, r0FAC, 0x03));
+ ir_expression *const r0AD0 = rshift(r0ACD, body.constant(int(12)));
+ ir_expression *const r0AD1 = lshift(r0AC0, body.constant(int(31)));
+ ir_expression *const r0AD2 = bit_or(r0AD1, body.constant(2146959360u));
+ body.emit(assign(r0ACE, bit_or(r0AD0, r0AD2), 0x02));
- body.emit(assign(r0F4F, body.constant(false), 0x01));
+ body.emit(assign(r0ABF, r0ACE, 0x03));
+ body.emit(assign(r0ABE, body.constant(false), 0x01));
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FA7->else_instructions;
- ir_variable *const r0FAD = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
- body.emit(r0FAD);
- ir_expression *const r0FAE = lshift(r0F51, body.constant(int(31)));
- body.emit(assign(r0FAD, add(r0FAE, body.constant(2146435072u)), 0x02));
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0ACB->else_instructions;
- body.emit(assign(r0FAD, body.constant(0u), 0x01));
+ ir_variable *const r0AD3 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0AD3);
+ ir_expression *const r0AD4 = lshift(r0AC0, body.constant(int(31)));
+ body.emit(assign(r0AD3, add(r0AD4, body.constant(2146435072u)), 0x02));
- body.emit(assign(r0F50, r0FAD, 0x03));
+ body.emit(assign(r0AD3, body.constant(0u), 0x01));
- body.emit(assign(r0F4F, body.constant(false), 0x01));
+ body.emit(assign(r0ABF, r0AD3, 0x03));
+ body.emit(assign(r0ABE, body.constant(false), 0x01));
- body.instructions = f0FA7_parent_instructions;
- body.emit(f0FA7);
- /* END IF */
+ body.instructions = f0ACB_parent_instructions;
+ body.emit(f0ACB);
+ /* END IF */
- body.instructions = f0F90_parent_instructions;
- body.emit(f0F90);
- /* END IF */
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0AC9->else_instructions;
+ /* IF CONDITION */
+ ir_expression *const r0AD6 = equal(r0AC6, body.constant(int(0)));
+ ir_if *f0AD5 = new(mem_ctx) ir_if(operand(r0AD6).val);
+ exec_list *const f0AD5_parent_instructions = body.instructions;
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0F8E->else_instructions;
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0AD5->then_instructions;
/* IF CONDITION */
- ir_expression *const r0FB0 = equal(r0F60, body.constant(int(0)));
- ir_if *f0FAF = new(mem_ctx) ir_if(operand(r0FB0).val);
- exec_list *const f0FAF_parent_instructions = body.instructions;
+ ir_expression *const r0AD8 = equal(r0AC5, body.constant(0u));
+ ir_if *f0AD7 = new(mem_ctx) ir_if(operand(r0AD8).val);
+ exec_list *const f0AD7_parent_instructions = body.instructions;
/* THEN INSTRUCTIONS */
- body.instructions = &f0FAF->then_instructions;
-
- /* IF CONDITION */
- ir_expression *const r0FB2 = bit_or(r0F5D, r0F4B);
- ir_expression *const r0FB3 = equal(r0FB2, body.constant(0u));
- ir_if *f0FB1 = new(mem_ctx) ir_if(operand(r0FB3).val);
- exec_list *const f0FB1_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FB1->then_instructions;
-
- ir_variable *const r0FB4 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
- body.emit(r0FB4);
- body.emit(assign(r0FB4, lshift(r0F51, body.constant(int(31))), 0x02));
-
- body.emit(assign(r0FB4, body.constant(0u), 0x01));
-
- body.emit(assign(r0F50, r0FB4, 0x03));
-
- body.emit(assign(r0F4F, body.constant(false), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FB1->else_instructions;
-
- ir_variable *const r0FB5 = body.make_temp(glsl_type::int_type, "zExpPtr");
- body.emit(assign(r0FB5, r0F60, 0x01));
-
- ir_variable *const r0FB6 = body.make_temp(glsl_type::uint_type, "zFrac0Ptr");
- body.emit(assign(r0FB6, r0F5D, 0x01));
-
- ir_variable *const r0FB7 = body.make_temp(glsl_type::uint_type, "zFrac1Ptr");
- body.emit(assign(r0FB7, r0F5C, 0x01));
-
- ir_variable *const r0FB8 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
- body.emit(r0FB8);
- /* IF CONDITION */
- ir_expression *const r0FBA = equal(r0F5D, body.constant(0u));
- ir_if *f0FB9 = new(mem_ctx) ir_if(operand(r0FBA).val);
- exec_list *const f0FB9_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FB9->then_instructions;
-
- ir_variable *const r0FBB = body.make_temp(glsl_type::uint_type, "a");
- body.emit(assign(r0FBB, r0F5C, 0x01));
-
- ir_variable *const r0FBC = body.make_temp(glsl_type::int_type, "return_value");
- ir_variable *const r0FBD = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
- body.emit(r0FBD);
- /* IF CONDITION */
- ir_expression *const r0FBF = equal(r0F4B, body.constant(0u));
- ir_if *f0FBE = new(mem_ctx) ir_if(operand(r0FBF).val);
- exec_list *const f0FBE_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FBE->then_instructions;
-
- body.emit(assign(r0FBC, body.constant(int(32)), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FBE->else_instructions;
-
- body.emit(assign(r0FBD, body.constant(int(0)), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r0FC1 = bit_and(r0F4B, body.constant(4294901760u));
- ir_expression *const r0FC2 = equal(r0FC1, body.constant(0u));
- ir_if *f0FC0 = new(mem_ctx) ir_if(operand(r0FC2).val);
- exec_list *const f0FC0_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FC0->then_instructions;
-
- body.emit(assign(r0FBD, body.constant(int(16)), 0x01));
-
- body.emit(assign(r0FBB, lshift(r0F4B, body.constant(int(16))), 0x01));
-
-
- body.instructions = f0FC0_parent_instructions;
- body.emit(f0FC0);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FC4 = bit_and(r0FBB, body.constant(4278190080u));
- ir_expression *const r0FC5 = equal(r0FC4, body.constant(0u));
- ir_if *f0FC3 = new(mem_ctx) ir_if(operand(r0FC5).val);
- exec_list *const f0FC3_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FC3->then_instructions;
-
- body.emit(assign(r0FBD, add(r0FBD, body.constant(int(8))), 0x01));
-
- body.emit(assign(r0FBB, lshift(r0FBB, body.constant(int(8))), 0x01));
-
-
- body.instructions = f0FC3_parent_instructions;
- body.emit(f0FC3);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FC7 = bit_and(r0FBB, body.constant(4026531840u));
- ir_expression *const r0FC8 = equal(r0FC7, body.constant(0u));
- ir_if *f0FC6 = new(mem_ctx) ir_if(operand(r0FC8).val);
- exec_list *const f0FC6_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FC6->then_instructions;
-
- body.emit(assign(r0FBD, add(r0FBD, body.constant(int(4))), 0x01));
-
- body.emit(assign(r0FBB, lshift(r0FBB, body.constant(int(4))), 0x01));
-
-
- body.instructions = f0FC6_parent_instructions;
- body.emit(f0FC6);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FCA = bit_and(r0FBB, body.constant(3221225472u));
- ir_expression *const r0FCB = equal(r0FCA, body.constant(0u));
- ir_if *f0FC9 = new(mem_ctx) ir_if(operand(r0FCB).val);
- exec_list *const f0FC9_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FC9->then_instructions;
-
- body.emit(assign(r0FBD, add(r0FBD, body.constant(int(2))), 0x01));
-
- body.emit(assign(r0FBB, lshift(r0FBB, body.constant(int(2))), 0x01));
-
-
- body.instructions = f0FC9_parent_instructions;
- body.emit(f0FC9);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FCD = bit_and(r0FBB, body.constant(2147483648u));
- ir_expression *const r0FCE = equal(r0FCD, body.constant(0u));
- ir_if *f0FCC = new(mem_ctx) ir_if(operand(r0FCE).val);
- exec_list *const f0FCC_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FCC->then_instructions;
-
- body.emit(assign(r0FBD, add(r0FBD, body.constant(int(1))), 0x01));
-
-
- body.instructions = f0FCC_parent_instructions;
- body.emit(f0FCC);
-
- /* END IF */
-
- body.emit(assign(r0FBC, r0FBD, 0x01));
-
-
- body.instructions = f0FBE_parent_instructions;
- body.emit(f0FBE);
-
- /* END IF */
-
- body.emit(assign(r0FB8, add(r0FBC, body.constant(int(-11))), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r0FD0 = less(r0FB8, body.constant(int(0)));
- ir_if *f0FCF = new(mem_ctx) ir_if(operand(r0FD0).val);
- exec_list *const f0FCF_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FCF->then_instructions;
-
- ir_expression *const r0FD1 = neg(r0FB8);
- body.emit(assign(r0FB6, rshift(r0F4B, r0FD1), 0x01));
-
- ir_expression *const r0FD2 = bit_and(r0FB8, body.constant(int(31)));
- body.emit(assign(r0FB7, lshift(r0F4B, r0FD2), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FCF->else_instructions;
-
- body.emit(assign(r0FB6, lshift(r0F4B, r0FB8), 0x01));
-
- body.emit(assign(r0FB7, body.constant(0u), 0x01));
-
-
- body.instructions = f0FCF_parent_instructions;
- body.emit(f0FCF);
-
- /* END IF */
-
- body.emit(assign(r0FB5, sub(body.constant(int(-31)), r0FB8), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FB9->else_instructions;
-
- ir_variable *const r0FD3 = body.make_temp(glsl_type::uint_type, "a");
- body.emit(assign(r0FD3, r0F5D, 0x01));
+ body.instructions = &f0AD7->then_instructions;
- ir_variable *const r0FD4 = body.make_temp(glsl_type::int_type, "return_value");
- ir_variable *const r0FD5 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
- body.emit(r0FD5);
- /* IF CONDITION */
- ir_expression *const r0FD7 = equal(r0F5D, body.constant(0u));
- ir_if *f0FD6 = new(mem_ctx) ir_if(operand(r0FD7).val);
- exec_list *const f0FD6_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FD6->then_instructions;
-
- body.emit(assign(r0FD4, body.constant(int(32)), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FD6->else_instructions;
-
- body.emit(assign(r0FD5, body.constant(int(0)), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r0FD9 = bit_and(r0F5D, body.constant(4294901760u));
- ir_expression *const r0FDA = equal(r0FD9, body.constant(0u));
- ir_if *f0FD8 = new(mem_ctx) ir_if(operand(r0FDA).val);
- exec_list *const f0FD8_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FD8->then_instructions;
-
- body.emit(assign(r0FD5, body.constant(int(16)), 0x01));
-
- body.emit(assign(r0FD3, lshift(r0F5D, body.constant(int(16))), 0x01));
-
-
- body.instructions = f0FD8_parent_instructions;
- body.emit(f0FD8);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FDC = bit_and(r0FD3, body.constant(4278190080u));
- ir_expression *const r0FDD = equal(r0FDC, body.constant(0u));
- ir_if *f0FDB = new(mem_ctx) ir_if(operand(r0FDD).val);
- exec_list *const f0FDB_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FDB->then_instructions;
-
- body.emit(assign(r0FD5, add(r0FD5, body.constant(int(8))), 0x01));
-
- body.emit(assign(r0FD3, lshift(r0FD3, body.constant(int(8))), 0x01));
-
-
- body.instructions = f0FDB_parent_instructions;
- body.emit(f0FDB);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FDF = bit_and(r0FD3, body.constant(4026531840u));
- ir_expression *const r0FE0 = equal(r0FDF, body.constant(0u));
- ir_if *f0FDE = new(mem_ctx) ir_if(operand(r0FE0).val);
- exec_list *const f0FDE_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FDE->then_instructions;
+ ir_variable *const r0AD9 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0AD9);
+ body.emit(assign(r0AD9, lshift(r0AC0, body.constant(int(31))), 0x02));
- body.emit(assign(r0FD5, add(r0FD5, body.constant(int(4))), 0x01));
+ body.emit(assign(r0AD9, body.constant(0u), 0x01));
- body.emit(assign(r0FD3, lshift(r0FD3, body.constant(int(4))), 0x01));
+ body.emit(assign(r0ABF, r0AD9, 0x03));
+ body.emit(assign(r0ABE, body.constant(false), 0x01));
- body.instructions = f0FDE_parent_instructions;
- body.emit(f0FDE);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FE2 = bit_and(r0FD3, body.constant(3221225472u));
- ir_expression *const r0FE3 = equal(r0FE2, body.constant(0u));
- ir_if *f0FE1 = new(mem_ctx) ir_if(operand(r0FE3).val);
- exec_list *const f0FE1_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FE1->then_instructions;
-
- body.emit(assign(r0FD5, add(r0FD5, body.constant(int(2))), 0x01));
-
- body.emit(assign(r0FD3, lshift(r0FD3, body.constant(int(2))), 0x01));
-
-
- body.instructions = f0FE1_parent_instructions;
- body.emit(f0FE1);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r0FE5 = bit_and(r0FD3, body.constant(2147483648u));
- ir_expression *const r0FE6 = equal(r0FE5, body.constant(0u));
- ir_if *f0FE4 = new(mem_ctx) ir_if(operand(r0FE6).val);
- exec_list *const f0FE4_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FE4->then_instructions;
-
- body.emit(assign(r0FD5, add(r0FD5, body.constant(int(1))), 0x01));
-
-
- body.instructions = f0FE4_parent_instructions;
- body.emit(f0FE4);
-
- /* END IF */
-
- body.emit(assign(r0FD4, r0FD5, 0x01));
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0AD7->else_instructions;
- body.instructions = f0FD6_parent_instructions;
- body.emit(f0FD6);
+ ir_variable *const r0ADA = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0ADB = equal(r0AC5, body.constant(0u));
+ ir_expression *const r0ADC = expr(ir_unop_find_msb, r0AC5);
+ ir_expression *const r0ADD = sub(body.constant(int(31)), r0ADC);
+ ir_expression *const r0ADE = expr(ir_triop_csel, r0ADB, body.constant(int(32)), r0ADD);
+ body.emit(assign(r0ADA, add(r0ADE, body.constant(int(-8))), 0x01));
- /* END IF */
+ body.emit(assign(r0AC2, lshift(r0AC5, r0ADA), 0x01));
- body.emit(assign(r0FB8, add(r0FD4, body.constant(int(-11))), 0x01));
+ body.emit(assign(r0AC1, sub(body.constant(int(1)), r0ADA), 0x01));
- ir_variable *const r0FE7 = body.make_temp(glsl_type::uint_type, "z1Ptr");
- body.emit(assign(r0FE7, lshift(r0F4B, r0FB8), 0x01));
+ body.emit(assign(r0AC1, add(r0AC1, body.constant(int(-1))), 0x01));
- ir_variable *const r0FE8 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
- /* IF CONDITION */
- ir_expression *const r0FEA = equal(r0FB8, body.constant(int(0)));
- ir_if *f0FE9 = new(mem_ctx) ir_if(operand(r0FEA).val);
- exec_list *const f0FE9_parent_instructions = body.instructions;
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FE9->then_instructions;
+ body.instructions = f0AD7_parent_instructions;
+ body.emit(f0AD7);
- body.emit(assign(r0FE8, r0F5D, 0x01));
+ /* END IF */
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FE9->else_instructions;
+ body.instructions = f0AD5_parent_instructions;
+ body.emit(f0AD5);
- ir_expression *const r0FEB = lshift(r0F5D, r0FB8);
- ir_expression *const r0FEC = neg(r0FB8);
- ir_expression *const r0FED = bit_and(r0FEC, body.constant(int(31)));
- ir_expression *const r0FEE = rshift(r0F4B, r0FED);
- body.emit(assign(r0FE8, bit_or(r0FEB, r0FEE), 0x01));
+ /* END IF */
+ /* IF CONDITION */
+ ir_if *f0ADF = new(mem_ctx) ir_if(operand(r0ABE).val);
+ exec_list *const f0ADF_parent_instructions = body.instructions;
- body.instructions = f0FE9_parent_instructions;
- body.emit(f0FE9);
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0ADF->then_instructions;
- /* END IF */
+ ir_variable *const r0AE0 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0AE0);
+ ir_expression *const r0AE1 = lshift(r0AC0, body.constant(int(31)));
+ ir_expression *const r0AE2 = add(r0AC1, body.constant(int(896)));
+ ir_expression *const r0AE3 = expr(ir_unop_i2u, r0AE2);
+ ir_expression *const r0AE4 = lshift(r0AE3, body.constant(int(20)));
+ ir_expression *const r0AE5 = add(r0AE1, r0AE4);
+ ir_expression *const r0AE6 = rshift(r0AC2, body.constant(int(3)));
+ body.emit(assign(r0AE0, add(r0AE5, r0AE6), 0x02));
- body.emit(assign(r0FB6, r0FE8, 0x01));
+ ir_expression *const r0AE7 = lshift(r0AC2, body.constant(int(29)));
+ body.emit(assign(r0AE0, bit_or(r0AE7, body.constant(0u)), 0x01));
- body.emit(assign(r0FB7, r0FE7, 0x01));
+ body.emit(assign(r0ABF, r0AE0, 0x03));
- body.emit(assign(r0FB5, sub(body.constant(int(1)), r0FB8), 0x01));
-
-
- body.instructions = f0FB9_parent_instructions;
- body.emit(f0FB9);
-
- /* END IF */
-
- body.emit(assign(r0F53, r0FB5, 0x01));
-
- body.emit(assign(r0F56, r0FB6, 0x01));
-
- body.emit(assign(r0F57, r0FB7, 0x01));
-
-
- body.instructions = f0FB1_parent_instructions;
- body.emit(f0FB1);
-
- /* END IF */
-
-
- body.instructions = f0FAF_parent_instructions;
- body.emit(f0FAF);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_if *f0FEF = new(mem_ctx) ir_if(operand(r0F4F).val);
- exec_list *const f0FEF_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FEF->then_instructions;
-
- /* IF CONDITION */
- ir_expression *const r0FF1 = equal(r0F63, body.constant(int(0)));
- ir_if *f0FF0 = new(mem_ctx) ir_if(operand(r0FF1).val);
- exec_list *const f0FF0_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FF0->then_instructions;
-
- /* IF CONDITION */
- ir_expression *const r0FF3 = bit_or(r0F5F, r0F4B);
- ir_expression *const r0FF4 = equal(r0FF3, body.constant(0u));
- ir_if *f0FF2 = new(mem_ctx) ir_if(operand(r0FF4).val);
- exec_list *const f0FF2_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FF2->then_instructions;
-
- ir_variable *const r0FF5 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
- body.emit(r0FF5);
- body.emit(assign(r0FF5, lshift(r0F51, body.constant(int(31))), 0x02));
-
- body.emit(assign(r0FF5, body.constant(0u), 0x01));
-
- body.emit(assign(r0F50, r0FF5, 0x03));
-
- body.emit(assign(r0F4F, body.constant(false), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FF2->else_instructions;
-
- ir_variable *const r0FF6 = body.make_temp(glsl_type::int_type, "zExpPtr");
- body.emit(assign(r0FF6, r0F63, 0x01));
-
- ir_variable *const r0FF7 = body.make_temp(glsl_type::uint_type, "zFrac0Ptr");
- body.emit(assign(r0FF7, r0F5F, 0x01));
-
- ir_variable *const r0FF8 = body.make_temp(glsl_type::uint_type, "zFrac1Ptr");
- body.emit(assign(r0FF8, r0F5E, 0x01));
-
- ir_variable *const r0FF9 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
- body.emit(r0FF9);
- /* IF CONDITION */
- ir_expression *const r0FFB = equal(r0F5F, body.constant(0u));
- ir_if *f0FFA = new(mem_ctx) ir_if(operand(r0FFB).val);
- exec_list *const f0FFA_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FFA->then_instructions;
-
- ir_variable *const r0FFC = body.make_temp(glsl_type::uint_type, "a");
- body.emit(assign(r0FFC, r0F5E, 0x01));
-
- ir_variable *const r0FFD = body.make_temp(glsl_type::int_type, "return_value");
- ir_variable *const r0FFE = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
- body.emit(r0FFE);
- /* IF CONDITION */
- ir_expression *const r1000 = equal(r0F4B, body.constant(0u));
- ir_if *f0FFF = new(mem_ctx) ir_if(operand(r1000).val);
- exec_list *const f0FFF_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f0FFF->then_instructions;
-
- body.emit(assign(r0FFD, body.constant(int(32)), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FFF->else_instructions;
-
- body.emit(assign(r0FFE, body.constant(int(0)), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r1002 = bit_and(r0F4B, body.constant(4294901760u));
- ir_expression *const r1003 = equal(r1002, body.constant(0u));
- ir_if *f1001 = new(mem_ctx) ir_if(operand(r1003).val);
- exec_list *const f1001_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1001->then_instructions;
-
- body.emit(assign(r0FFE, body.constant(int(16)), 0x01));
-
- body.emit(assign(r0FFC, lshift(r0F4B, body.constant(int(16))), 0x01));
-
-
- body.instructions = f1001_parent_instructions;
- body.emit(f1001);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r1005 = bit_and(r0FFC, body.constant(4278190080u));
- ir_expression *const r1006 = equal(r1005, body.constant(0u));
- ir_if *f1004 = new(mem_ctx) ir_if(operand(r1006).val);
- exec_list *const f1004_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1004->then_instructions;
-
- body.emit(assign(r0FFE, add(r0FFE, body.constant(int(8))), 0x01));
-
- body.emit(assign(r0FFC, lshift(r0FFC, body.constant(int(8))), 0x01));
-
-
- body.instructions = f1004_parent_instructions;
- body.emit(f1004);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r1008 = bit_and(r0FFC, body.constant(4026531840u));
- ir_expression *const r1009 = equal(r1008, body.constant(0u));
- ir_if *f1007 = new(mem_ctx) ir_if(operand(r1009).val);
- exec_list *const f1007_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1007->then_instructions;
-
- body.emit(assign(r0FFE, add(r0FFE, body.constant(int(4))), 0x01));
-
- body.emit(assign(r0FFC, lshift(r0FFC, body.constant(int(4))), 0x01));
-
-
- body.instructions = f1007_parent_instructions;
- body.emit(f1007);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r100B = bit_and(r0FFC, body.constant(3221225472u));
- ir_expression *const r100C = equal(r100B, body.constant(0u));
- ir_if *f100A = new(mem_ctx) ir_if(operand(r100C).val);
- exec_list *const f100A_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f100A->then_instructions;
-
- body.emit(assign(r0FFE, add(r0FFE, body.constant(int(2))), 0x01));
-
- body.emit(assign(r0FFC, lshift(r0FFC, body.constant(int(2))), 0x01));
-
-
- body.instructions = f100A_parent_instructions;
- body.emit(f100A);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r100E = bit_and(r0FFC, body.constant(2147483648u));
- ir_expression *const r100F = equal(r100E, body.constant(0u));
- ir_if *f100D = new(mem_ctx) ir_if(operand(r100F).val);
- exec_list *const f100D_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f100D->then_instructions;
-
- body.emit(assign(r0FFE, add(r0FFE, body.constant(int(1))), 0x01));
-
-
- body.instructions = f100D_parent_instructions;
- body.emit(f100D);
-
- /* END IF */
-
- body.emit(assign(r0FFD, r0FFE, 0x01));
-
-
- body.instructions = f0FFF_parent_instructions;
- body.emit(f0FFF);
-
- /* END IF */
-
- body.emit(assign(r0FF9, add(r0FFD, body.constant(int(-11))), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r1011 = less(r0FF9, body.constant(int(0)));
- ir_if *f1010 = new(mem_ctx) ir_if(operand(r1011).val);
- exec_list *const f1010_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1010->then_instructions;
-
- ir_expression *const r1012 = neg(r0FF9);
- body.emit(assign(r0FF7, rshift(r0F4B, r1012), 0x01));
-
- ir_expression *const r1013 = bit_and(r0FF9, body.constant(int(31)));
- body.emit(assign(r0FF8, lshift(r0F4B, r1013), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f1010->else_instructions;
-
- body.emit(assign(r0FF7, lshift(r0F4B, r0FF9), 0x01));
-
- body.emit(assign(r0FF8, body.constant(0u), 0x01));
-
-
- body.instructions = f1010_parent_instructions;
- body.emit(f1010);
-
- /* END IF */
-
- body.emit(assign(r0FF6, sub(body.constant(int(-31)), r0FF9), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f0FFA->else_instructions;
-
- ir_variable *const r1014 = body.make_temp(glsl_type::uint_type, "a");
- body.emit(assign(r1014, r0F5F, 0x01));
-
- ir_variable *const r1015 = body.make_temp(glsl_type::int_type, "return_value");
- ir_variable *const r1016 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
- body.emit(r1016);
- /* IF CONDITION */
- ir_expression *const r1018 = equal(r0F5F, body.constant(0u));
- ir_if *f1017 = new(mem_ctx) ir_if(operand(r1018).val);
- exec_list *const f1017_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1017->then_instructions;
-
- body.emit(assign(r1015, body.constant(int(32)), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f1017->else_instructions;
-
- body.emit(assign(r1016, body.constant(int(0)), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r101A = bit_and(r0F5F, body.constant(4294901760u));
- ir_expression *const r101B = equal(r101A, body.constant(0u));
- ir_if *f1019 = new(mem_ctx) ir_if(operand(r101B).val);
- exec_list *const f1019_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1019->then_instructions;
-
- body.emit(assign(r1016, body.constant(int(16)), 0x01));
-
- body.emit(assign(r1014, lshift(r0F5F, body.constant(int(16))), 0x01));
-
-
- body.instructions = f1019_parent_instructions;
- body.emit(f1019);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r101D = bit_and(r1014, body.constant(4278190080u));
- ir_expression *const r101E = equal(r101D, body.constant(0u));
- ir_if *f101C = new(mem_ctx) ir_if(operand(r101E).val);
- exec_list *const f101C_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f101C->then_instructions;
-
- body.emit(assign(r1016, add(r1016, body.constant(int(8))), 0x01));
-
- body.emit(assign(r1014, lshift(r1014, body.constant(int(8))), 0x01));
-
-
- body.instructions = f101C_parent_instructions;
- body.emit(f101C);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r1020 = bit_and(r1014, body.constant(4026531840u));
- ir_expression *const r1021 = equal(r1020, body.constant(0u));
- ir_if *f101F = new(mem_ctx) ir_if(operand(r1021).val);
- exec_list *const f101F_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f101F->then_instructions;
-
- body.emit(assign(r1016, add(r1016, body.constant(int(4))), 0x01));
-
- body.emit(assign(r1014, lshift(r1014, body.constant(int(4))), 0x01));
-
-
- body.instructions = f101F_parent_instructions;
- body.emit(f101F);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r1023 = bit_and(r1014, body.constant(3221225472u));
- ir_expression *const r1024 = equal(r1023, body.constant(0u));
- ir_if *f1022 = new(mem_ctx) ir_if(operand(r1024).val);
- exec_list *const f1022_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1022->then_instructions;
-
- body.emit(assign(r1016, add(r1016, body.constant(int(2))), 0x01));
-
- body.emit(assign(r1014, lshift(r1014, body.constant(int(2))), 0x01));
-
-
- body.instructions = f1022_parent_instructions;
- body.emit(f1022);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_expression *const r1026 = bit_and(r1014, body.constant(2147483648u));
- ir_expression *const r1027 = equal(r1026, body.constant(0u));
- ir_if *f1025 = new(mem_ctx) ir_if(operand(r1027).val);
- exec_list *const f1025_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1025->then_instructions;
-
- body.emit(assign(r1016, add(r1016, body.constant(int(1))), 0x01));
-
-
- body.instructions = f1025_parent_instructions;
- body.emit(f1025);
-
- /* END IF */
-
- body.emit(assign(r1015, r1016, 0x01));
-
-
- body.instructions = f1017_parent_instructions;
- body.emit(f1017);
-
- /* END IF */
-
- body.emit(assign(r0FF9, add(r1015, body.constant(int(-11))), 0x01));
-
- ir_variable *const r1028 = body.make_temp(glsl_type::uint_type, "z1Ptr");
- body.emit(assign(r1028, lshift(r0F4B, r0FF9), 0x01));
-
- ir_variable *const r1029 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
- /* IF CONDITION */
- ir_expression *const r102B = equal(r0FF9, body.constant(int(0)));
- ir_if *f102A = new(mem_ctx) ir_if(operand(r102B).val);
- exec_list *const f102A_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f102A->then_instructions;
-
- body.emit(assign(r1029, r0F5F, 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f102A->else_instructions;
-
- ir_expression *const r102C = lshift(r0F5F, r0FF9);
- ir_expression *const r102D = neg(r0FF9);
- ir_expression *const r102E = bit_and(r102D, body.constant(int(31)));
- ir_expression *const r102F = rshift(r0F4B, r102E);
- body.emit(assign(r1029, bit_or(r102C, r102F), 0x01));
-
-
- body.instructions = f102A_parent_instructions;
- body.emit(f102A);
-
- /* END IF */
-
- body.emit(assign(r0FF7, r1029, 0x01));
-
- body.emit(assign(r0FF8, r1028, 0x01));
-
- body.emit(assign(r0FF6, sub(body.constant(int(1)), r0FF9), 0x01));
-
-
- body.instructions = f0FFA_parent_instructions;
- body.emit(f0FFA);
-
- /* END IF */
-
- body.emit(assign(r0F52, r0FF6, 0x01));
-
- body.emit(assign(r0F54, r0FF7, 0x01));
-
- body.emit(assign(r0F55, r0FF8, 0x01));
-
-
- body.instructions = f0FF2_parent_instructions;
- body.emit(f0FF2);
-
- /* END IF */
-
-
- body.instructions = f0FF0_parent_instructions;
- body.emit(f0FF0);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_if *f1030 = new(mem_ctx) ir_if(operand(r0F4F).val);
- exec_list *const f1030_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f1030->then_instructions;
-
- ir_expression *const r1031 = add(r0F53, r0F52);
- body.emit(assign(r0F58, add(r1031, body.constant(int(-1024))), 0x01));
-
- body.emit(assign(r0F56, bit_or(r0F56, body.constant(1048576u)), 0x01));
-
- ir_variable *const r1032 = body.make_temp(glsl_type::uint_type, "z1Ptr");
- body.emit(assign(r1032, lshift(r0F55, body.constant(int(12))), 0x01));
-
- ir_variable *const r1033 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
- ir_expression *const r1034 = lshift(r0F54, body.constant(int(12)));
- ir_expression *const r1035 = rshift(r0F55, body.constant(int(20)));
- body.emit(assign(r1033, bit_or(r1034, r1035), 0x01));
-
- body.emit(assign(r0F54, r1033, 0x01));
-
- body.emit(assign(r0F55, r1032, 0x01));
-
- ir_variable *const r1036 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
- body.emit(r1036);
- ir_variable *const r1037 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
- body.emit(r1037);
- ir_variable *const r1038 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
- body.emit(r1038);
- ir_variable *const r1039 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1039, bit_and(r0F57, body.constant(65535u)), 0x01));
-
- ir_variable *const r103A = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r103A, rshift(r0F57, body.constant(int(16))), 0x01));
-
- ir_variable *const r103B = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r103B, bit_and(r1032, body.constant(65535u)), 0x01));
-
- ir_variable *const r103C = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r103C, rshift(r1032, body.constant(int(16))), 0x01));
-
- ir_variable *const r103D = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r103D, mul(r103A, r103B), 0x01));
-
- ir_expression *const r103E = mul(r1039, r103C);
- body.emit(assign(r1037, add(r103E, r103D), 0x01));
-
- ir_expression *const r103F = mul(r103A, r103C);
- ir_expression *const r1040 = less(r1037, r103D);
- ir_expression *const r1041 = expr(ir_unop_b2i, r1040);
- ir_expression *const r1042 = expr(ir_unop_i2u, r1041);
- ir_expression *const r1043 = lshift(r1042, body.constant(int(16)));
- ir_expression *const r1044 = rshift(r1037, body.constant(int(16)));
- ir_expression *const r1045 = add(r1043, r1044);
- body.emit(assign(r1036, add(r103F, r1045), 0x01));
-
- body.emit(assign(r1037, lshift(r1037, body.constant(int(16))), 0x01));
-
- ir_expression *const r1046 = mul(r1039, r103B);
- body.emit(assign(r1038, add(r1046, r1037), 0x01));
-
- ir_expression *const r1047 = less(r1038, r1037);
- ir_expression *const r1048 = expr(ir_unop_b2i, r1047);
- ir_expression *const r1049 = expr(ir_unop_i2u, r1048);
- body.emit(assign(r1036, add(r1036, r1049), 0x01));
-
- ir_variable *const r104A = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
- body.emit(r104A);
- ir_variable *const r104B = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
- body.emit(r104B);
- ir_variable *const r104C = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
- body.emit(r104C);
- ir_variable *const r104D = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r104D, bit_and(r0F57, body.constant(65535u)), 0x01));
-
- ir_variable *const r104E = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r104E, rshift(r0F57, body.constant(int(16))), 0x01));
-
- ir_variable *const r104F = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r104F, bit_and(r1033, body.constant(65535u)), 0x01));
-
- ir_variable *const r1050 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1050, rshift(r1033, body.constant(int(16))), 0x01));
-
- ir_variable *const r1051 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1051, mul(r104E, r104F), 0x01));
-
- ir_expression *const r1052 = mul(r104D, r1050);
- body.emit(assign(r104B, add(r1052, r1051), 0x01));
-
- ir_expression *const r1053 = mul(r104E, r1050);
- ir_expression *const r1054 = less(r104B, r1051);
- ir_expression *const r1055 = expr(ir_unop_b2i, r1054);
- ir_expression *const r1056 = expr(ir_unop_i2u, r1055);
- ir_expression *const r1057 = lshift(r1056, body.constant(int(16)));
- ir_expression *const r1058 = rshift(r104B, body.constant(int(16)));
- ir_expression *const r1059 = add(r1057, r1058);
- body.emit(assign(r104A, add(r1053, r1059), 0x01));
-
- body.emit(assign(r104B, lshift(r104B, body.constant(int(16))), 0x01));
-
- ir_expression *const r105A = mul(r104D, r104F);
- body.emit(assign(r104C, add(r105A, r104B), 0x01));
-
- ir_expression *const r105B = less(r104C, r104B);
- ir_expression *const r105C = expr(ir_unop_b2i, r105B);
- ir_expression *const r105D = expr(ir_unop_i2u, r105C);
- body.emit(assign(r104A, add(r104A, r105D), 0x01));
-
- ir_variable *const r105E = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r105E, add(r104C, r1036), 0x01));
-
- ir_variable *const r105F = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
- body.emit(r105F);
- ir_variable *const r1060 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
- body.emit(r1060);
- ir_variable *const r1061 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
- body.emit(r1061);
- ir_variable *const r1062 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1062, bit_and(r0F56, body.constant(65535u)), 0x01));
-
- ir_variable *const r1063 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1063, rshift(r0F56, body.constant(int(16))), 0x01));
-
- ir_variable *const r1064 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1064, bit_and(r1033, body.constant(65535u)), 0x01));
-
- ir_variable *const r1065 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1065, rshift(r1033, body.constant(int(16))), 0x01));
-
- ir_variable *const r1066 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1066, mul(r1063, r1064), 0x01));
-
- ir_expression *const r1067 = mul(r1062, r1065);
- body.emit(assign(r1060, add(r1067, r1066), 0x01));
-
- ir_expression *const r1068 = mul(r1063, r1065);
- ir_expression *const r1069 = less(r1060, r1066);
- ir_expression *const r106A = expr(ir_unop_b2i, r1069);
- ir_expression *const r106B = expr(ir_unop_i2u, r106A);
- ir_expression *const r106C = lshift(r106B, body.constant(int(16)));
- ir_expression *const r106D = rshift(r1060, body.constant(int(16)));
- ir_expression *const r106E = add(r106C, r106D);
- body.emit(assign(r105F, add(r1068, r106E), 0x01));
-
- body.emit(assign(r1060, lshift(r1060, body.constant(int(16))), 0x01));
-
- ir_expression *const r106F = mul(r1062, r1064);
- body.emit(assign(r1061, add(r106F, r1060), 0x01));
-
- ir_expression *const r1070 = less(r1061, r1060);
- ir_expression *const r1071 = expr(ir_unop_b2i, r1070);
- ir_expression *const r1072 = expr(ir_unop_i2u, r1071);
- body.emit(assign(r105F, add(r105F, r1072), 0x01));
-
- ir_variable *const r1073 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- ir_expression *const r1074 = less(r105E, r104C);
- ir_expression *const r1075 = expr(ir_unop_b2i, r1074);
- ir_expression *const r1076 = expr(ir_unop_i2u, r1075);
- ir_expression *const r1077 = add(r104A, r1076);
- body.emit(assign(r1073, add(r1061, r1077), 0x01));
-
- ir_variable *const r1078 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
- body.emit(r1078);
- ir_variable *const r1079 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
- body.emit(r1079);
- ir_variable *const r107A = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
- body.emit(r107A);
- ir_variable *const r107B = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r107B, bit_and(r0F56, body.constant(65535u)), 0x01));
-
- ir_variable *const r107C = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r107C, rshift(r0F56, body.constant(int(16))), 0x01));
-
- ir_variable *const r107D = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r107D, bit_and(r1032, body.constant(65535u)), 0x01));
-
- ir_variable *const r107E = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r107E, rshift(r1032, body.constant(int(16))), 0x01));
-
- ir_variable *const r107F = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r107F, mul(r107C, r107D), 0x01));
-
- ir_expression *const r1080 = mul(r107B, r107E);
- body.emit(assign(r1079, add(r1080, r107F), 0x01));
-
- ir_expression *const r1081 = mul(r107C, r107E);
- ir_expression *const r1082 = less(r1079, r107F);
- ir_expression *const r1083 = expr(ir_unop_b2i, r1082);
- ir_expression *const r1084 = expr(ir_unop_i2u, r1083);
- ir_expression *const r1085 = lshift(r1084, body.constant(int(16)));
- ir_expression *const r1086 = rshift(r1079, body.constant(int(16)));
- ir_expression *const r1087 = add(r1085, r1086);
- body.emit(assign(r1078, add(r1081, r1087), 0x01));
-
- body.emit(assign(r1079, lshift(r1079, body.constant(int(16))), 0x01));
-
- ir_expression *const r1088 = mul(r107B, r107D);
- body.emit(assign(r107A, add(r1088, r1079), 0x01));
-
- ir_expression *const r1089 = less(r107A, r1079);
- ir_expression *const r108A = expr(ir_unop_b2i, r1089);
- ir_expression *const r108B = expr(ir_unop_i2u, r108A);
- body.emit(assign(r1078, add(r1078, r108B), 0x01));
-
- ir_variable *const r108C = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r108C, add(r107A, r105E), 0x01));
-
- ir_variable *const r108D = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- ir_expression *const r108E = less(r108C, r107A);
- ir_expression *const r108F = expr(ir_unop_b2i, r108E);
- ir_expression *const r1090 = expr(ir_unop_i2u, r108F);
- ir_expression *const r1091 = add(r1078, r1090);
- body.emit(assign(r108D, add(r1073, r1091), 0x01));
-
- ir_variable *const r1092 = body.make_temp(glsl_type::uint_type, "z0Ptr");
- ir_variable *const r1093 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r1093, add(r108D, r0F57), 0x01));
-
- ir_expression *const r1094 = less(r1073, r1061);
- ir_expression *const r1095 = expr(ir_unop_b2i, r1094);
- ir_expression *const r1096 = expr(ir_unop_i2u, r1095);
- ir_expression *const r1097 = add(r105F, r1096);
- ir_expression *const r1098 = less(r108D, r1073);
- ir_expression *const r1099 = expr(ir_unop_b2i, r1098);
- ir_expression *const r109A = expr(ir_unop_i2u, r1099);
- ir_expression *const r109B = add(r1097, r109A);
- ir_expression *const r109C = add(r109B, r0F56);
- ir_expression *const r109D = less(r1093, r108D);
- ir_expression *const r109E = expr(ir_unop_b2i, r109D);
- ir_expression *const r109F = expr(ir_unop_i2u, r109E);
- body.emit(assign(r1092, add(r109C, r109F), 0x01));
-
- body.emit(assign(r0F5B, r1092, 0x01));
-
- body.emit(assign(r0F5A, r1093, 0x01));
-
- ir_expression *const r10A0 = nequal(r1038, body.constant(0u));
- ir_expression *const r10A1 = expr(ir_unop_b2i, r10A0);
- ir_expression *const r10A2 = expr(ir_unop_i2u, r10A1);
- body.emit(assign(r0F59, bit_or(r108C, r10A2), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r10A4 = lequal(body.constant(2097152u), r1092);
- ir_if *f10A3 = new(mem_ctx) ir_if(operand(r10A4).val);
- exec_list *const f10A3_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10A3->then_instructions;
-
- ir_variable *const r10A5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
- body.emit(r10A5);
- body.emit(assign(r10A5, lshift(r1093, body.constant(int(31))), 0x01));
-
- ir_expression *const r10A6 = nequal(r0F59, body.constant(0u));
- ir_expression *const r10A7 = expr(ir_unop_b2i, r10A6);
- ir_expression *const r10A8 = expr(ir_unop_i2u, r10A7);
- body.emit(assign(r10A5, bit_or(r10A5, r10A8), 0x01));
-
- body.emit(assign(r0F5B, rshift(r1092, body.constant(int(1))), 0x01));
-
- ir_expression *const r10A9 = lshift(r1092, body.constant(int(31)));
- ir_expression *const r10AA = rshift(r1093, body.constant(int(1)));
- body.emit(assign(r0F5A, bit_or(r10A9, r10AA), 0x01));
-
- body.emit(assign(r0F59, r10A5, 0x01));
-
- body.emit(assign(r0F58, add(r0F58, body.constant(int(1))), 0x01));
-
-
- body.instructions = f10A3_parent_instructions;
- body.emit(f10A3);
-
- /* END IF */
-
- ir_variable *const r10AB = body.make_temp(glsl_type::int_type, "zExp");
- body.emit(assign(r10AB, r0F58, 0x01));
-
- ir_variable *const r10AC = body.make_temp(glsl_type::uint_type, "zFrac0");
- body.emit(assign(r10AC, r0F5B, 0x01));
-
- ir_variable *const r10AD = body.make_temp(glsl_type::uint_type, "zFrac1");
- body.emit(assign(r10AD, r0F5A, 0x01));
-
- ir_variable *const r10AE = body.make_temp(glsl_type::uint_type, "zFrac2");
- body.emit(assign(r10AE, r0F59, 0x01));
-
- ir_variable *const r10AF = body.make_temp(glsl_type::bool_type, "execute_flag");
- body.emit(assign(r10AF, body.constant(true), 0x01));
-
- ir_variable *const r10B0 = body.make_temp(glsl_type::uvec2_type, "return_value");
- ir_variable *const r10B1 = new(mem_ctx) ir_variable(glsl_type::bool_type, "increment", ir_var_auto);
- body.emit(r10B1);
- ir_expression *const r10B2 = expr(ir_unop_u2i, r0F59);
- body.emit(assign(r10B1, less(r10B2, body.constant(int(0))), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r10B4 = lequal(body.constant(int(2045)), r0F58);
- ir_if *f10B3 = new(mem_ctx) ir_if(operand(r10B4).val);
- exec_list *const f10B3_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10B3->then_instructions;
-
- /* IF CONDITION */
- ir_expression *const r10B6 = less(body.constant(int(2045)), r0F58);
- ir_expression *const r10B7 = equal(r0F58, body.constant(int(2045)));
- ir_expression *const r10B8 = equal(body.constant(2097151u), r0F5B);
- ir_expression *const r10B9 = equal(body.constant(4294967295u), r0F5A);
- ir_expression *const r10BA = logic_and(r10B8, r10B9);
- ir_expression *const r10BB = logic_and(r10B7, r10BA);
- ir_expression *const r10BC = logic_and(r10BB, r10B1);
- ir_expression *const r10BD = logic_or(r10B6, r10BC);
- ir_if *f10B5 = new(mem_ctx) ir_if(operand(r10BD).val);
- exec_list *const f10B5_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10B5->then_instructions;
-
- ir_variable *const r10BE = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
- body.emit(r10BE);
- ir_expression *const r10BF = lshift(r0F51, body.constant(int(31)));
- body.emit(assign(r10BE, add(r10BF, body.constant(2146435072u)), 0x02));
-
- body.emit(assign(r10BE, body.constant(0u), 0x01));
-
- body.emit(assign(r10B0, r10BE, 0x03));
-
- body.emit(assign(r10AF, body.constant(false), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f10B5->else_instructions;
-
- /* IF CONDITION */
- ir_expression *const r10C1 = less(r0F58, body.constant(int(0)));
- ir_if *f10C0 = new(mem_ctx) ir_if(operand(r10C1).val);
- exec_list *const f10C0_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10C0->then_instructions;
-
- ir_variable *const r10C2 = body.make_temp(glsl_type::uint_type, "a2");
- body.emit(assign(r10C2, r0F59, 0x01));
-
- ir_variable *const r10C3 = body.make_temp(glsl_type::int_type, "count");
- body.emit(assign(r10C3, neg(r0F58), 0x01));
-
- ir_variable *const r10C4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
- body.emit(r10C4);
- ir_variable *const r10C5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
- body.emit(r10C5);
- ir_variable *const r10C6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
- body.emit(r10C6);
- ir_variable *const r10C7 = body.make_temp(glsl_type::int_type, "assignment_tmp");
- ir_expression *const r10C8 = neg(r10C3);
- body.emit(assign(r10C7, bit_and(r10C8, body.constant(int(31))), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r10CA = equal(r10C3, body.constant(int(0)));
- ir_if *f10C9 = new(mem_ctx) ir_if(operand(r10CA).val);
- exec_list *const f10C9_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10C9->then_instructions;
-
- body.emit(assign(r10C4, r0F59, 0x01));
-
- body.emit(assign(r10C5, r0F5A, 0x01));
-
- body.emit(assign(r10C6, r0F5B, 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f10C9->else_instructions;
-
- /* IF CONDITION */
- ir_expression *const r10CC = less(r10C3, body.constant(int(32)));
- ir_if *f10CB = new(mem_ctx) ir_if(operand(r10CC).val);
- exec_list *const f10CB_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10CB->then_instructions;
-
- body.emit(assign(r10C4, lshift(r0F5A, r10C7), 0x01));
-
- ir_expression *const r10CD = lshift(r0F5B, r10C7);
- ir_expression *const r10CE = rshift(r0F5A, r10C3);
- body.emit(assign(r10C5, bit_or(r10CD, r10CE), 0x01));
-
- body.emit(assign(r10C6, rshift(r0F5B, r10C3), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f10CB->else_instructions;
-
- /* IF CONDITION */
- ir_expression *const r10D0 = equal(r10C3, body.constant(int(32)));
- ir_if *f10CF = new(mem_ctx) ir_if(operand(r10D0).val);
- exec_list *const f10CF_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10CF->then_instructions;
-
- body.emit(assign(r10C4, r0F5A, 0x01));
-
- body.emit(assign(r10C5, r0F5B, 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f10CF->else_instructions;
-
- body.emit(assign(r10C2, bit_or(r0F59, r0F5A), 0x01));
-
- /* IF CONDITION */
- ir_expression *const r10D2 = less(r10C3, body.constant(int(64)));
- ir_if *f10D1 = new(mem_ctx) ir_if(operand(r10D2).val);
- exec_list *const f10D1_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10D1->then_instructions;
-
- body.emit(assign(r10C4, lshift(r0F5B, r10C7), 0x01));
-
- ir_expression *const r10D3 = bit_and(r10C3, body.constant(int(31)));
- body.emit(assign(r10C5, rshift(r0F5B, r10D3), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f10D1->else_instructions;
-
- ir_variable *const r10D4 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
- /* IF CONDITION */
- ir_expression *const r10D6 = equal(r10C3, body.constant(int(64)));
- ir_if *f10D5 = new(mem_ctx) ir_if(operand(r10D6).val);
- exec_list *const f10D5_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10D5->then_instructions;
-
- body.emit(assign(r10D4, r0F5B, 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f10D5->else_instructions;
-
- ir_expression *const r10D7 = nequal(r0F5B, body.constant(0u));
- ir_expression *const r10D8 = expr(ir_unop_b2i, r10D7);
- body.emit(assign(r10D4, expr(ir_unop_i2u, r10D8), 0x01));
-
-
- body.instructions = f10D5_parent_instructions;
- body.emit(f10D5);
-
- /* END IF */
-
- body.emit(assign(r10C4, r10D4, 0x01));
-
- body.emit(assign(r10C5, body.constant(0u), 0x01));
-
-
- body.instructions = f10D1_parent_instructions;
- body.emit(f10D1);
-
- /* END IF */
-
-
- body.instructions = f10CF_parent_instructions;
- body.emit(f10CF);
-
- /* END IF */
-
- body.emit(assign(r10C6, body.constant(0u), 0x01));
-
-
- body.instructions = f10CB_parent_instructions;
- body.emit(f10CB);
-
- /* END IF */
-
- ir_expression *const r10D9 = nequal(r10C2, body.constant(0u));
- ir_expression *const r10DA = expr(ir_unop_b2i, r10D9);
- ir_expression *const r10DB = expr(ir_unop_i2u, r10DA);
- body.emit(assign(r10C4, bit_or(r10C4, r10DB), 0x01));
-
-
- body.instructions = f10C9_parent_instructions;
- body.emit(f10C9);
-
- /* END IF */
-
- body.emit(assign(r10AC, r10C6, 0x01));
-
- body.emit(assign(r10AD, r10C5, 0x01));
-
- body.emit(assign(r10AE, r10C4, 0x01));
-
- body.emit(assign(r10AB, body.constant(int(0)), 0x01));
-
- body.emit(assign(r10B1, less(r10C4, body.constant(0u)), 0x01));
-
-
- body.instructions = f10C0_parent_instructions;
- body.emit(f10C0);
-
- /* END IF */
-
-
- body.instructions = f10B5_parent_instructions;
- body.emit(f10B5);
-
- /* END IF */
-
-
- body.instructions = f10B3_parent_instructions;
- body.emit(f10B3);
-
- /* END IF */
-
- /* IF CONDITION */
- ir_if *f10DC = new(mem_ctx) ir_if(operand(r10AF).val);
- exec_list *const f10DC_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10DC->then_instructions;
-
- /* IF CONDITION */
- ir_if *f10DD = new(mem_ctx) ir_if(operand(r10B1).val);
- exec_list *const f10DD_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10DD->then_instructions;
-
- ir_variable *const r10DE = body.make_temp(glsl_type::uint_type, "assignment_tmp");
- body.emit(assign(r10DE, add(r10AD, body.constant(1u)), 0x01));
-
- ir_expression *const r10DF = less(r10DE, r10AD);
- ir_expression *const r10E0 = expr(ir_unop_b2i, r10DF);
- ir_expression *const r10E1 = expr(ir_unop_i2u, r10E0);
- body.emit(assign(r10AC, add(r10AC, r10E1), 0x01));
-
- ir_expression *const r10E2 = equal(r10AE, body.constant(0u));
- ir_expression *const r10E3 = expr(ir_unop_b2i, r10E2);
- ir_expression *const r10E4 = expr(ir_unop_i2u, r10E3);
- ir_expression *const r10E5 = add(r10AE, r10E4);
- ir_expression *const r10E6 = bit_and(r10E5, body.constant(1u));
- ir_expression *const r10E7 = expr(ir_unop_bit_not, r10E6);
- body.emit(assign(r10AD, bit_and(r10DE, r10E7), 0x01));
-
-
- /* ELSE INSTRUCTIONS */
- body.instructions = &f10DD->else_instructions;
-
- /* IF CONDITION */
- ir_expression *const r10E9 = bit_or(r10AC, r10AD);
- ir_expression *const r10EA = equal(r10E9, body.constant(0u));
- ir_if *f10E8 = new(mem_ctx) ir_if(operand(r10EA).val);
- exec_list *const f10E8_parent_instructions = body.instructions;
-
- /* THEN INSTRUCTIONS */
- body.instructions = &f10E8->then_instructions;
-
- body.emit(assign(r10AB, body.constant(int(0)), 0x01));
-
-
- body.instructions = f10E8_parent_instructions;
- body.emit(f10E8);
-
- /* END IF */
-
-
- body.instructions = f10DD_parent_instructions;
- body.emit(f10DD);
-
- /* END IF */
-
- ir_variable *const r10EB = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
- body.emit(r10EB);
- ir_expression *const r10EC = lshift(r0F51, body.constant(int(31)));
- ir_expression *const r10ED = expr(ir_unop_i2u, r10AB);
- ir_expression *const r10EE = lshift(r10ED, body.constant(int(20)));
- ir_expression *const r10EF = add(r10EC, r10EE);
- body.emit(assign(r10EB, add(r10EF, r10AC), 0x02));
-
- body.emit(assign(r10EB, r10AD, 0x01));
-
- body.emit(assign(r10B0, r10EB, 0x03));
-
- body.emit(assign(r10AF, body.constant(false), 0x01));
-
-
- body.instructions = f10DC_parent_instructions;
- body.emit(f10DC);
-
- /* END IF */
-
- body.emit(assign(r0F50, r10B0, 0x03));
-
- body.emit(assign(r0F4F, body.constant(false), 0x01));
-
-
- body.instructions = f1030_parent_instructions;
- body.emit(f1030);
-
- /* END IF */
-
-
- body.instructions = f0FEF_parent_instructions;
- body.emit(f0FEF);
-
- /* END IF */
+ body.emit(assign(r0ABE, body.constant(false), 0x01));
- body.instructions = f0F8E_parent_instructions;
- body.emit(f0F8E);
+ body.instructions = f0ADF_parent_instructions;
+ body.emit(f0ADF);
/* END IF */
- body.instructions = f0F68_parent_instructions;
- body.emit(f0F68);
+ body.instructions = f0AC9_parent_instructions;
+ body.emit(f0AC9);
/* END IF */
- body.emit(ret(r0F50));
+ body.emit(ret(r0ABF));
sig->replace_parameters(&sig_parameters);
return sig;
diff --git a/src/compiler/glsl/float64.glsl b/src/compiler/glsl/float64.glsl
index dd5496d..51e2a3d 100644
--- a/src/compiler/glsl/float64.glsl
+++ b/src/compiler/glsl/float64.glsl
@@ -1356,8 +1356,10 @@ uvec2
frcp64(uvec2 a)
{
/* pow(x, -0,5) */
- sub64(0xBFCDD6A1u, 0x8F6A6F52u, a.y, a.x, a.y, a.x);
- shift64Right(a.y, a.x, 1, a.y, a.x);
+// sub64(0xBFCDD6A1u, 0x8F6A6F52u, a.y, a.x, a.y, a.x);
+// shift64Right(a.y, a.x, 1, a.y, a.x);
/* pow(pow(x, -0.5), 2) = pow(x, -1) = 1/x */
- return fmul64(a, a);
+// return fmul64(a, a);
+
+ return fp32_to_fp64(1.0/fp64_to_fp32(a));
}
diff --git a/src/compiler/glsl/ir_optimization.h b/src/compiler/glsl/ir_optimization.h
index 44d07bc..3c99ae0 100644
--- a/src/compiler/glsl/ir_optimization.h
+++ b/src/compiler/glsl/ir_optimization.h
@@ -74,10 +74,12 @@
#define SQRT64 (1U << 15)
#define TRUNC64 (1U << 16)
#define ROUND64 (1U << 17)
+#define RCP64 (1U << 18)
#define LOWER_ALL_DOUBLE_OPS (ABS64 | NEG64 | SIGN64 | EQ64 | LT64 | \
ADD64 | MUL64 | D2U | U2D | D2I | I2D | \
- D2F | F2D | SQRT64 | TRUNC64 | ROUND64)
+ D2F | F2D | SQRT64 | TRUNC64 | ROUND64 | \
+ RCP64)
/**
* \see class lower_packing_builtins_visitor
diff --git a/src/compiler/glsl/lower_64bit.cpp b/src/compiler/glsl/lower_64bit.cpp
index 38c264f..ee6d6f9 100644
--- a/src/compiler/glsl/lower_64bit.cpp
+++ b/src/compiler/glsl/lower_64bit.cpp
@@ -466,6 +466,13 @@ lower_64bit_visitor::handle_rvalue(ir_rvalue **rvalue)
}
break;
+ case ir_unop_rcp:
+ if (lowering(RCP64)) {
+ if (ir->type->base_type == GLSL_TYPE_DOUBLE)
+ *rvalue = handle_op(ir, "__builtin_frcp64", generate_ir::frcp64);
+ }
+ break;
+
case ir_unop_round_even:
if (lowering(ROUND64)) {
if (ir->type->base_type == GLSL_TYPE_DOUBLE)
--
2.9.5
More information about the mesa-dev
mailing list